chaffjs 0.18.0 → 0.19.0

package/src/detectors/lexicon.ts

@@ -8,6 +8,7 @@ import { namesQuantity } from "./superlative-name.ts";
 import { namesAmount } from "./superlative-amount.ts";
 import { restricted, type Restrictors } from "./superlative-clause.ts";
 import { stackedHedges, type StackedHedge } from "./stacked-hedge.ts";
+import { comparisonMarkersOf, counterpartBefore, onlyQuoted, quotedRange, type ComparisonMarkers } from "./superlative-comparison.ts";
 
 const PER = 1000;
 
@@ -19,30 +20,52 @@ type Hit = { readonly sentence: Sentence; readonly matched: string };
 const hitsFor = (doc: ProseDocument, lexicon: Lexicon): Hit[] =>
   doc.sentences.flatMap((sentence) => lexicon.filter((entry) => entryIn(sentence, entry)).map((entry) => ({ sentence, matched: entry.pattern })));
 
+/**
+ * 床より短い文書の扱い。skip は測らない。at-floor は SHORT_LENGTH の長さの文書として測り、一つだけなら言わない（一つは礼儀）。
+ * クッション言葉はメールや手紙のような短い文書に重なるので at-floor。逃げの表現は短い文書でも一文に重ねた形で見つかるので skip。
+ */
+type ShortDocuments = "skip" | "at-floor";
+
+/** 短い文書を測るときの長さ。どちらの言語でも、既定の水準で三つ目から言う長さ（二つは「お忙しいところ恐れ入りますが」のように普通に重なる）。 */
+const SHORT_LENGTH = { word: 400, char: 500 };
+
+/** 短い文書でも、これより少なければ言わない。 */
+const SHORT_MINIMUM_HITS = 2;
+
+const perThousand = (count: number, length: number): number => (length === 0 ? 0 : Math.round((count / length) * PER));
+
 /**
  * 単位長あたりの出現率。件数で数えると長い文書ほど当たる（bold-density と同じ）。
- * rule の id は呼び出し側が持つ。detector は「密度が閾値を超えたか」しか知らない。
+ * 短すぎて測らない文書、1 つも無いとき、閾値に収まるときは undefined。
  */
+export const rateOver = (doc: ProseDocument, count: number, limit: number): number | undefined => {
+  const length = wordsOf(doc);
+  const rate = perThousand(count, length);
+  return length < FLOOR[doc.lengthUnit] || count === 0 || rate <= limit ? undefined : rate;
+};
+
+/** rule の id は呼び出し側が持つ。detector は「密度が閾値を超えたか」しか知らない。指摘が言う密度は、短い文書でも文書の実際の長さでの値。 */
 const densityRule =
-  (rule: string): Detector =>
+  (rule: string, short: ShortDocuments = "skip"): Detector =>
   (doc, options): Finding[] => {
     const hits = hitsFor(doc, options.lexicon ?? []);
     const length = wordsOf(doc);
-    const rate = length === 0 ? 0 : Math.round((hits.length / length) * PER);
-    const first = hits[0];
-    if (length < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+    const isShort = length < FLOOR[doc.lengthUnit];
+    if (hits.length === 0 || (isShort && (short === "skip" || hits.length < SHORT_MINIMUM_HITS))) return [];
+    if (perThousand(hits.length, isShort ? SHORT_LENGTH[doc.lengthUnit] : length) <= options.limit) return [];
+    const density = perThousand(hits.length, length);
     return hits.map((hit) => ({
       rule,
       severity: "warning",
       line: 0,
       column: 0,
       quote: hit.sentence.text.trim(),
-      values: { matched: hit.matched, count: hits.length, density: rate, limit: options.limit, offset: hit.sentence.span.start },
+      values: { matched: hit.matched, count: hits.length, density, limit: options.limit, offset: hit.sentence.span.start },
     }));
   };
 
 const hedgingDensity = densityRule("excessive-hedging");
-export const cushionDensity = densityRule("cushion-phrase-density");
+export const cushionDensity = densityRule("cushion-phrase-density", "at-floor");
 
 /** 書いたとおりの字。行の折り返しをまたいでいたら空白 1 つに。 */
 const writtenAt = (source: string, span: Span): string => source.slice(span.start, span.end).replace(/\s+/gu, " ").trim();
@@ -83,7 +106,7 @@ export const hedging: Detector = (doc, options): Finding[] => {
 const DIGIT = /\d/u;
 
 type Qualifiers = {
-  readonly comparison: Lexicon;
+  readonly comparison: ComparisonMarkers;
   readonly scope: ScopeMarkers;
   readonly quantityNouns: Lexicon;
   readonly amounts: Lexicon;
@@ -91,7 +114,7 @@ type Qualifiers = {
 };
 
 const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
-  comparison: doc.lexicons["comparison-marker"] ?? [],
+  comparison: comparisonMarkersOf(doc.lexicons["comparison-marker"] ?? []),
   scope: scopeMarkersOf(doc.lexicons["superlative-scope"] ?? []),
   quantityNouns: doc.lexicons["quantity-noun"] ?? [],
   amounts: doc.lexicons["superlative-amount"] ?? [],
@@ -102,22 +125,26 @@ const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
   },
 });
 
-/** 範囲・節・分詞・形容詞のどれかが最上級を限っているか、最上級が量か名前を言っているか。 */
+/** 範囲・節・分詞・形容詞・すぐ前の相手のどれかが最上級を限っているか、最上級が量か名前を言っているか。 */
 const qualifiedAt = (tokens: readonly Token[], range: TokenRange, qualifiers: Qualifiers): boolean =>
+  counterpartBefore(tokens, range, qualifiers.comparison.before) ||
   scoped(tokens, range, qualifiers.scope) ||
   restricted(tokens, range, qualifiers.restrictors) ||
   namesQuantity(tokens, range, qualifiers.quantityNouns) ||
   namesAmount(tokens, range, qualifiers.amounts);
 
-/** どの出現も限られているか量を言うときだけ。1 つでもそうでない出現があれば、その文には限定の無い最上級がある。 */
+/** どの出現も引いた言葉か、限られているか、量を言うときだけ。1 つでもそうでない出現があれば、その文には限定の無い最上級がある。 */
 const everyQualified = (sentence: Sentence, entry: LexiconEntry, qualifiers: Qualifiers): boolean => {
   const tokens = sentence.tokens ?? [];
   const ranges = entryRanges(sentence, entry);
-  return ranges.length > 0 && ranges.every((range) => qualifiedAt(tokens, range, qualifiers));
+  return ranges.length > 0 && ranges.every((range) => quotedRange(sentence, range) || qualifiedAt(tokens, range, qualifiers));
 };
 
 const qualified = (sentence: Sentence, entry: LexiconEntry, qualifiers: Qualifiers): boolean =>
-  DIGIT.test(sentence.text) || qualifiers.comparison.some((marker) => entryIn(sentence, marker)) || everyQualified(sentence, entry, qualifiers);
+  DIGIT.test(sentence.text) ||
+  onlyQuoted(sentence, entry) ||
+  qualifiers.comparison.anywhere.some((marker) => entryIn(sentence, marker)) ||
+  everyQualified(sentence, entry, qualifiers);
 
 const bareHits = (doc: ProseDocument, lexicon: Lexicon): Hit[] => {
   const qualifiers = qualifiersOf(doc);

package/src/detectors/list-sentence.ts

@@ -1,12 +1,18 @@
-import type { Lexicon, Token } from "../plugin.ts";
+import type { Lexicon, LexiconEntry, Token } from "../plugin.ts";
 import { citedTitles } from "./cited-title.ts";
 import { columnOf, type Column } from "./token-column.ts";
 
 /**
  * 並びを読むための語彙表。participle は解析器が分詞と読まないが読点のあとで分詞の句を始める語（meaning）、
- * example は例を挙げる句（such as, e.g.）、pair は 2 つだけを結ぶ語とその接続詞（between and / either or）。
+ * example は例を挙げる句（such as, e.g.）、pair は 2 つだけを結ぶ語とその接続詞（between and / either or）、
+ * region は地名のあとに読点を挟んで添える州や国の名（New London, Wisconsin）。
  */
-export type ListWords = { readonly participle: ReadonlySet<string>; readonly example: Lexicon; readonly pair: ReadonlySet<string> };
+export type ListWords = {
+  readonly participle: ReadonlySet<string>;
+  readonly example: Lexicon;
+  readonly pair: ReadonlySet<string>;
+  readonly region: Lexicon;
+};
 
 const LIST_CONJUNCTION: ReadonlySet<string> = new Set(["and", "or"]);
 
@@ -60,6 +66,40 @@ const byDepth = (depths: readonly number[], test: (index: number) => boolean): R
 
 const isComma = (token: Token): boolean => token.surface === ",";
 
+const surfacesOf = ({ pattern, tokens: words = [] }: LexiconEntry): string[] => (words.length > 0 ? words.map((word) => word.surface) : pattern.split(" "));
+
+const writtenAt = (tokens: readonly Token[], start: number, entry: LexiconEntry): boolean =>
+  surfacesOf(entry).every((surface, offset) => tokens[start + offset]?.surface === surface);
+
+/** start から書いてある州や国の名。語ごとに書いたとおりに照らす。 */
+const regionAt = (tokens: readonly Token[], start: number, regions: Lexicon): LexiconEntry | undefined =>
+  regions.find((entry) => writtenAt(tokens, start, entry));
+
+/** 名の後ろが文や句の切れ目（, . ; : ) か文の終わり）。New London, Wisconsin, and … の Wisconsin。 */
+const closesName = (token: Token | undefined): boolean => token === undefined || [",", ".", ";", ":", ")"].includes(token.surface);
+
+/** at の直前が州や国の名で終わる（Texas, Florida, … の Texas）。名の長さの分だけ前から照らす。 */
+const endsWithRegion = (tokens: readonly Token[], at: number, regions: Lexicon): boolean =>
+  regions.some((entry) => {
+    const start = at - surfacesOf(entry).length;
+    return start >= 0 && writtenAt(tokens, start, entry);
+  });
+
+/**
+ * 地名と、それに添えた州や国の名のあいだの読点（New London, Wisconsin, and a photo / Lyon, France, then）。並びの区切りではない。
+ * 前が固有名詞で、それ自身が州や国の名でなく（Texas, Florida, and Ohio は州の並び）、後ろの名が切れ目で閉じるときだけ。
+ * 地名の後ろにしか書かない名（position: after。Washington, D.C.）は、前が州の名でも地名に添えたもの。
+ */
+const regionCommasOf = (tokens: readonly Token[], regions: Lexicon): ReadonlySet<number> =>
+  new Set(
+    tokens.flatMap((token, at) => {
+      if (!isComma(token) || tokens[at - 1]?.pos !== "PROPN") return [];
+      const region = regionAt(tokens, at + 1, regions);
+      if (region === undefined || !closesName(tokens[at + 1 + surfacesOf(region).length])) return [];
+      return region.position === "after" || !endsWithRegion(tokens, at, regions) ? [at] : [];
+    }),
+  );
+
 /** 項目への問いの列。読点は項目に入ったり入らなかったりするので、脇に置いて問いごとに数える（token-column.ts）。 */
 const columnsOf = (tokens: readonly Token[], depths: readonly number[]) => {
   const commaDepth = (token: Token, index: number): number | undefined => (isComma(token) ? depths[index] : undefined);
@@ -143,6 +183,7 @@ export const listSentenceOf = (tokens: readonly Token[], words: ListWords, sourc
   const depths = depthsOf(tokens);
   const column = columnsOf(tokens, depths);
   const exampleEnds = exampleEndsOf(tokens, depths, column, words.example);
+  const regionCommas = regionCommasOf(tokens, words.region);
   return {
     tokens,
     depths,
@@ -151,7 +192,7 @@ export const listSentenceOf = (tokens: readonly Token[], words: ListWords, sourc
     exampleEnds,
     exampleStarts: byDepth(depths, (index) => (exampleEnds[index]?.length ?? 0) > 0),
     pairOpeners: pairOpenersOf(tokens, depths, words.pair),
-    commas: byDepth(depths, (index) => tokens[index]?.surface === ","),
+    commas: byDepth(depths, (index) => tokens[index]?.surface === "," && !regionCommas.has(index)),
     inCitedTitle: citedTitles(tokens, source),
   };
 };

package/src/detectors/long-vowel.ts

@@ -9,12 +9,28 @@ const endingOf = (value: OptionValue | undefined): Ending => ENDINGS.find((endin
 const wordsOf = (value: OptionValue | undefined): readonly string[] =>
   Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : [];
 
-/** The minimum when no setting gives one: three morae, as the guidelines that drop the ー count it. */
-const DEFAULT_MIN_MORAE = 3;
+/** The minimum when no setting gives one: two morae before the final ー, which leaves カー alone. */
+const DEFAULT_MIN_MORAE = 2;
 
 /** A listed word is exempt written either way: listing コンピューター exempts コンピュータ too. */
 const exemptStems = (except: readonly string[]): ReadonlySet<string> => new Set(except.map((word) => stemOf(word.trim())));
 
+/**
+ * Words that become another word with a final ー (フリ, as in 振り, and フリー, free): the language's long-vowel-distinct word list.
+ * Both are nouns to the tagger, so only the list tells them apart; they are left out as if listed under except.
+ * The list is optional: without it the rule still runs and compares every word.
+ */
+const distinctWordsOf = (doc: ProseDocument): string[] => (doc.lexicons["long-vowel-distinct"] ?? []).map((entry) => entry.pattern);
+
+/**
+ * The kana a final ー follows where drop drops it: the language's long-vowel-drop-after list (ア段, the -er, -or, -ar of
+ * JIS Z 8301:2011 G.6.2.2). Without the list, drop reaches every final ー.
+ */
+const dropAfterOf = (doc: ProseDocument): ReadonlySet<string> | undefined => {
+  const kana = doc.lexicons["long-vowel-drop-after"];
+  return kana === undefined ? undefined : new Set(kana.map((entry) => entry.pattern));
+};
+
 /**
  * The katakana nouns of a sentence, as the language adapter split them: ユーザー inside ユーザーインターフェース is its own word.
  * Proper nouns (PROPN) and the team's names keep their own spelling (ディズニー).
@@ -42,9 +58,9 @@ const quoteAt = (doc: ProseDocument, offset: number): string =>
 export const katakanaLongVowel: Detector = (doc, options): Finding[] => {
   const settings = options.settings ?? {};
   const minMorae = typeof settings["min_morae"] === "number" ? settings["min_morae"] : DEFAULT_MIN_MORAE;
-  const exempt = exemptStems(wordsOf(settings["except"]));
+  const exempt = exemptStems([...wordsOf(settings["except"]), ...distinctWordsOf(doc)]);
   const words = doc.sentences.flatMap((sentence) => kanaWordsOf(sentence, doc.names ?? [], exempt));
-  const odd = oddLongVowels(words, endingOf(settings["ending"]), minMorae);
+  const odd = oddLongVowels(words, endingOf(settings["ending"]), minMorae, dropAfterOf(doc));
   if (odd.length === 0 || odd.length < options.limit) return [];
   return odd.map((entry) => ({
     rule: "",

package/src/detectors/markup-finding.ts

@@ -1,4 +1,5 @@
-import type { Finding, Markup, ProseDocument, Span } from "../plugin.ts";
+import type { Finding, Markup, MarkupHeading, ProseDocument, Span } from "../plugin.ts";
+import { hasTitle } from "../heading-title.ts";
 
 // 記法の rule（見出し・画像・リンク・URL）が指摘を作る形。
 
@@ -22,3 +23,17 @@ export const findingAt = (doc: ProseDocument, span: Span, values: Readonly<Recor
 
 /** Markdown の文書の記法。Markdown でなければ undefined。 */
 export const markupOf = (doc: ProseDocument): Markup | undefined => (doc.markup?.markdown === true ? doc.markup : undefined);
+
+/** 文の終わりの句点。下線で書く見出し（setext）の言葉がこれで終わるなら、区切り線の上の文。 */
+const SENTENCE_END = /[.。!?！？]$/u;
+
+/**
+ * 下線で書く見出し（setext）のうち、区切り線（メールの「-----」）の上の段落を Markdown が見出しと読んだもの。
+ * 二行以上にわたるか、句点で終わる。書き手は見出しを立てていない。
+ */
+const isUnderlinedParagraph = (source: string, heading: MarkupHeading): boolean =>
+  !source.startsWith("#", heading.start) && (heading.text.includes("\n") || SENTENCE_END.test(heading.text));
+
+/** 見出しとして書いた見出し。題の無い見出し（`## ---`）と、区切り線の上の段落は外す。 */
+export const writtenHeadings = (doc: ProseDocument): MarkupHeading[] =>
+  (markupOf(doc)?.headings ?? []).filter((heading) => hasTitle(heading.text) && !isUnderlinedParagraph(doc.source, heading));

package/src/detectors/modal-conflict.ts

@@ -0,0 +1,26 @@
+import type { Detector, Finding, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { modalConflicts, modalStatements, type Obligation } from "../structure/modal-conflict.ts";
+import { linesOf, lineNumberAt } from "../structure/lines.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const obligationsOf = (tree: StructureNode): Obligation[] =>
+  inDocumentOrder(tree).flatMap((node) =>
+    node.kind === "obligation"
+      ? [{ start: node.span.start, end: node.span.end, type: String(node.attrs["type"] ?? ""), marker: String(node.attrs["marker"] ?? "") }]
+      : [],
+  );
+
+/** 同じ主語と行為に、前の文と逆の様相（しなければならない と してはならない、may と must not）を書いた文。 */
+export const modalConflict: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const lines = linesOf(doc.source);
+  return modalConflicts(modalStatements(obligationsOf(doc.structure), doc.sentences)).map(({ statement, earlier }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, statement.offset),
+    values: { marker: statement.marker, other: earlier.marker, otherLine: lineNumberAt(lines, earlier.offset) ?? 0, offset: statement.offset },
+  }));
+};

package/src/detectors/name-variant.ts

@@ -0,0 +1,15 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { mentionsIn, nameVariants } from "../name-variants.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
+export const nameVariant: Detector = (doc): Finding[] =>
+  nameVariants(doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source))).map(({ mention, usual, kind }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mention.offset),
+    values: { name: mention.surface, usual, offset: mention.offset },
+    variant: kind,
+  }));

package/src/detectors/nominalization.ts

@@ -0,0 +1,73 @@
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Token } from "../plugin.ts";
+import { entryRanges, type TokenRange } from "./lexicon-match.ts";
+import { rateOver } from "./lexicon.ts";
+
+// A verb written as a noun and carried by another verb: 調査を実施した for 調査した, "make a decision" for "decide"
+// (the やさしい日本語 guideline; the Federal Plain Language Guidelines' hidden verbs; GOV.UK). Two shapes, each from a
+// lexicon the language may or may not have: a whole phrase with its verb (nominalization-phrase), or a verbal noun
+// (the adapter's VerbForm=Vnoun) followed by a carrying verb (nominalization-light-verb). Counted as a density.
+
+export type Hidden = { readonly sentence: Sentence; readonly offset: number; readonly matched: string; readonly preferred: string };
+
+const PHRASES = "nominalization-phrase";
+const LIGHT_VERBS = "nominalization-light-verb";
+/** Verbal nouns whose carrying verb means "hold" (研修を実施する is not 研修する): not hidden verbs. */
+const EVENT_NOUNS = "nominalization-event-noun";
+
+const isVerbalNoun = (token: Token | undefined): token is Token => token?.features?.["VerbForm"] === "Vnoun";
+
+const writtenBetween = (source: string, tokens: readonly Token[], range: TokenRange): string => {
+  const [first, last] = [tokens[range.start], tokens[range.end - 1]];
+  return first === undefined || last === undefined ? "" : source.slice(first.span.start, last.span.end);
+};
+
+/** A phrase of the lexicon, with the verb it hides (instead_of). */
+const phrasesIn = (sentence: Sentence, source: string, phrases: Lexicon): Hidden[] =>
+  phrases.flatMap((entry) =>
+    entryRanges(sentence, entry).map((range) => ({
+      sentence,
+      offset: sentence.tokens?.[range.start]?.span.start ?? sentence.span.start,
+      matched: writtenBetween(source, sentence.tokens ?? [], range),
+      preferred: entry.instead_of ?? "",
+    })),
+  );
+
+/**
+ * A carrying verb right after a verbal noun: 調査 + を実施した. Both sides are named in the dictionary form, the noun and the
+ * entry (調査を実施する), and the verb to write is the noun and the entry's instead_of (調査 + する).
+ */
+const lightVerbsIn = (sentence: Sentence, lightVerbs: Lexicon, eventNouns: ReadonlySet<string>): Hidden[] => {
+  const tokens = sentence.tokens ?? [];
+  return lightVerbs.flatMap((entry) =>
+    entryRanges(sentence, entry).flatMap((range): Hidden[] => {
+      const noun = tokens[range.start - 1];
+      if (!isVerbalNoun(noun) || eventNouns.has(noun.surface)) return [];
+      return [{ sentence, offset: noun.span.start, matched: `${noun.surface}${entry.pattern}`, preferred: `${noun.surface}${entry.instead_of ?? ""}` }];
+    }),
+  );
+};
+
+/** Pure: every hidden verb in the document, in the order they are written. */
+export const hiddenVerbs = (doc: Pick<ProseDocument, "sentences" | "source" | "lexicons">): Hidden[] => {
+  const eventNouns = new Set((doc.lexicons[EVENT_NOUNS] ?? []).map((entry) => entry.pattern));
+  return doc.sentences
+    .flatMap((sentence) => [
+      ...phrasesIn(sentence, doc.source, doc.lexicons[PHRASES] ?? []),
+      ...lightVerbsIn(sentence, doc.lexicons[LIGHT_VERBS] ?? [], eventNouns),
+    ])
+    .toSorted((left, right) => left.offset - right.offset);
+};
+
+export const nominalization: Detector = (doc, options): Finding[] => {
+  const hidden = hiddenVerbs(doc);
+  const rate = rateOver(doc, hidden.length, options.limit);
+  if (rate === undefined) return [];
+  return hidden.map((found) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: found.sentence.text.trim(),
+    values: { matched: found.matched, preferred: found.preferred, count: hidden.length, density: rate, limit: options.limit, offset: found.offset },
+  }));
+};

package/src/detectors/orthography.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
 import { calendarRuns, calendarUnitsOf, type CalendarUnits } from "../calendar-number.ts";
-import { latinBoundaries, minorityStyle, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
+import { escapeRegExp, latinBoundaries, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
+import { minorityReport } from "../spacing-minority.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStarts, type NameContext } from "../number-name.ts";
 
@@ -36,17 +37,43 @@ const digitBeside = (boundary: Boundary): number => {
  * 文書全体で一度だけ読むもの（number-name.ts の NameContext に加えて）。calendar は日付・時刻の単位、
  * divisions は「第1節」のように「第」と番号の後ろに書く区切りの語。
  */
-type NumberContext = NameContext & { readonly calendar: CalendarUnits; readonly divisions: ReadonlySet<string> };
+type NumberContext = NameContext & {
+  readonly calendar: CalendarUnits;
+  readonly divisions: ReadonlySet<string>;
+  readonly itemNumbers: ReadonlySet<string>;
+};
+
+/** 文頭の項目の番号の後ろと見る境目の位置の上限。番号は短く文の頭にあるので、これより後ろの境目は番号の後ろではない。長い文で文頭からの切り出しを繰り返さない。 */
+const ITEM_NUMBER_REACH = 8;
+
+/** 行の頭の字下げと箇条書きの印。 */
+const ITEM_LEAD = /^[\s\-*+]*/u;
+
+/**
+ * 文書が項目の番号として行の頭に並べたもの（語彙表 item-number は並びの順）。行の頭に空白で本文と区切って書かれ、
+ * 前か次の番号も同じように書かれているものだけ。「一」「二」は番号、前後の無い「十 GBまで」の十は数量。
+ */
+const numberedItems = (ordered: readonly string[], source: string): ReadonlySet<string> => {
+  if (ordered.length === 0) return new Set();
+  const labels = ordered.toSorted((left, right) => right.length - left.length).map(escapeRegExp);
+  const atHead = new Set([...source.matchAll(new RegExp(`^[ \\t\\-*+]*(${labels.join("|")})[ \\u3000]`, "gmu"))].map((match) => match[1]));
+  return new Set(ordered.filter((label, at) => atHead.has(label) && (atHead.has(ordered[at - 1]) || atHead.has(ordered[at + 1]))));
+};
+
+/** 境目が、文頭の項目の番号と本文を分ける空白か（「一 JIS」）。 */
+const followsItemNumber = (text: string, boundary: Boundary, itemNumbers: ReadonlySet<string>): boolean =>
+  boundary.spaced && boundary.offset <= ITEM_NUMBER_REACH && itemNumbers.has(text.slice(0, boundary.offset).replace(ITEM_LEAD, ""));
 
 /** 文の中の日付・時刻の数の、並びの頭の位置。 */
 const calendarStarts = (sentence: Sentence, units: CalendarUnits): ReadonlySet<number> =>
   new Set(calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run }) => run.start));
 
 /**
- * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目は、空け方の好みではないので数えない。
+ * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目、文頭の項目の番号（「一 JIS」）の後ろの境目は、空け方の好みではないので数えない。
  * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。
  */
 const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlySet<number>): boolean => {
+  if (followsItemNumber(sentence.text, boundary, context.itemNumbers)) return false;
   if (boundary.kind !== "after-digit" && endsWithDivisionLabel(sentence.text.slice(0, boundary.offset), context.divisions)) return false;
   if (boundary.kind === "letter") return true;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
@@ -68,6 +95,43 @@ const labelsAt = (doc: ProseDocument, position: "before" | "after"): ReadonlySet
  */
 const isQuoted = (quoted: readonly Span[], boundary: Boundary): boolean => isWithinAny(quoted, { start: boundary.offset, end: boundary.offset });
 
+/**
+ * リンクの文字の中の境目。リンクの文字は引いた記事や資料の題であることが多く、空け方は元のものなので、鉤括弧の中と同じに数えない。
+ * リンクの外側の端（「を [記事]」の空白）は書き手の空け方なので数える。at は文書全体の位置。
+ */
+const isInsideLink = (links: readonly Span[], at: number): boolean => links.some((link) => link.start < at && at < link.end);
+
+const findingAt = (entry: Located, values: Finding["values"], variant?: string): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: entry.sentence.text.trim(),
+  ...(variant === undefined ? {} : { variant }),
+  values: { ...values, offset: entry.sentence.span.start + entry.offset },
+});
+
+/** 一つの種類の境目の指摘。少ないほうを 1 箇所ずつか、書き方が二通りあれば 1 件で（spacing-minority.ts）。 */
+const findingsOf = (kind: SpacingKind, ofKind: readonly Located[], limit: number): Finding[] => {
+  const report = minorityReport(ofKind, limit);
+  if (report === undefined) return [];
+  if (report.mode === "mixed") {
+    const { first, odd, spaced, touching } = report;
+    return [findingAt(first, { kind: KIND_NAME[kind], spaced, touching, count: odd, of: ofKind.length, limit }, "mixed")];
+  }
+  const minority = report.odd[0]?.spaced ?? false;
+  return report.odd.map((entry) =>
+    findingAt(entry, {
+      kind: KIND_NAME[kind],
+      style: minority ? "空けています" : "詰めています",
+      usual: minority ? "詰める" : "空ける",
+      count: report.odd.length,
+      of: ofKind.length,
+      limit,
+    }),
+  );
+};
+
 /**
  * 日本語と英字・数字のあいだを、空けるか詰めるか。文書の中で混ざっていたら、少ないほうを指摘する。
  * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
@@ -80,35 +144,21 @@ export const latinSpacing: Detector = (doc, options): Finding[] => {
     labelWords: labelsAt(doc, "before"),
     calendar: calendarUnitsOf(doc),
     divisions: labelsAt(doc, "after"),
+    itemNumbers: numberedItems(patternList(doc, "item-number"), doc.prose ?? doc.source),
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);
     const calendar = calendarStarts(sentence, context.calendar);
     return latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
-      .filter((boundary) => !isQuoted(quoted, boundary) && isCounted(sentence, boundary, context, calendar))
+      .filter((boundary) => !isQuoted(quoted, boundary) && !isInsideLink(doc.links, sentence.span.start + boundary.offset))
+      .filter((boundary) => isCounted(sentence, boundary, context, calendar))
       .map((boundary) => ({ sentence, ...boundary }));
   });
-  return KINDS.flatMap((kind) => {
-    const ofKind = located.filter((entry) => entry.kind === kind);
-    const minority = minorityStyle(ofKind);
-    if (minority === undefined) return [];
-    const odd = ofKind.filter((entry) => entry.spaced === minority);
-    if (odd.length < options.limit) return [];
-    return odd.map((entry) => ({
-      rule: "",
-      severity: "warning",
-      line: 0,
-      column: 0,
-      quote: entry.sentence.text.trim(),
-      values: {
-        kind: KIND_NAME[kind],
-        style: minority ? "空けています" : "詰めています",
-        usual: minority ? "詰める" : "空ける",
-        count: odd.length,
-        of: ofKind.length,
-        limit: options.limit,
-        offset: entry.sentence.span.start + entry.offset,
-      },
-    }));
-  });
+  return KINDS.flatMap((kind) =>
+    findingsOf(
+      kind,
+      located.filter((entry) => entry.kind === kind),
+      options.limit,
+    ),
+  );
 };

package/src/detectors/outside-announced-list.ts

@@ -0,0 +1,25 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { listStatementsIn, outsideMembers } from "../announced-list.ts";
+import { linesOf, lineNumberAt } from "../structure/lines.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** 最初に挙げた一覧（対応 OS は Windows と macOS）に無い名前を、後の文が同じ語で言う所（Linux にも対応）。 */
+export const outsideAnnouncedList: Detector = (doc): Finding[] => {
+  const lowered = (id: string): Set<string> => new Set((doc.lexicons[id] ?? []).map((entry) => entry.pattern.toLowerCase()));
+  const words = { frames: doc.lexicons["enumeration-frame"] ?? [], joiners: lowered("enumeration-joiner"), negations: lowered("enumeration-negation") };
+  const statements = doc.sentences.flatMap((sentence) => listStatementsIn(sentence, words, doc.source));
+  const lines = linesOf(doc.source);
+  return outsideMembers(statements).map(({ member, announced }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, member.offset),
+    values: {
+      name: member.name,
+      list: announced.members.map((listed) => listed.name).join(", "),
+      listLine: lineNumberAt(lines, announced.offset) ?? 0,
+      offset: member.offset,
+    },
+  }));
+};

package/src/detectors/oxford-comma.ts

@@ -274,6 +274,7 @@ export const oxfordComma: Detector = (doc, options): Finding[] => {
     participle: patternsOf(doc.lexicons["participle-word"]),
     example: doc.lexicons["example-marker"] ?? [],
     pair: patternsOf(doc.lexicons["pair-opener"]),
+    region: doc.lexicons["place-region"] ?? [],
   };
   const judged = doc.sentences.flatMap((sentence) => {
     const oxford = oxfordIn(sentence.tokens ?? [], words, doc.source);

package/src/detectors/phrase-match.ts

@@ -1,5 +1,6 @@
 import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
-import { entryIn } from "./lexicon-match.ts";
+import { entryEnds, entryIn } from "./lexicon-match.ts";
+import { closingSentences } from "../closing-paragraph.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
 const OPENING_SENTENCES = 4;
@@ -10,7 +11,7 @@ const OPENING_SENTENCES = 4;
  */
 const inScope = (doc: ProseDocument, where: string | undefined): readonly Sentence[] => {
   if (where === "opening") return doc.sentences.slice(0, OPENING_SENTENCES);
-  if (where === "closing") return doc.sections.at(-1)?.sentences ?? [];
+  if (where === "closing") return closingSentences(doc.sections, doc.paragraphs);
   return doc.sentences;
 };
 
@@ -22,14 +23,14 @@ const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
     return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
-const findingsOf = (hits: readonly Hit[], limit: number): Finding[] =>
+const findingsOf = (hits: readonly Hit[], limit: number, count = hits.length): Finding[] =>
   hits.map((hit) => ({
     rule: "",
     severity: "warning",
     line: 0,
     column: 0,
     quote: hit.sentence.text.trim(),
-    values: { matched: hit.matched, count: hits.length, limit, offset: hit.sentence.span.start },
+    values: { matched: hit.matched, count, limit, offset: hit.sentence.span.start },
   }));
 
 const phraseHits = (doc: ProseDocument, options: DetectorOptions): Hit[] => {
@@ -46,8 +47,27 @@ export const phraseMatch: Detector = (doc, options): Finding[] => {
   return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
 };
 
-/** 回数に上限がある語。limit は許す回数で、それを超えたときだけ言う。message の「N 回まで」と同じ向き。 */
+type Uses = { readonly sentence: Sentence; readonly matched: string; readonly count: number };
+
+/**
+ * 文の中の出現の数。語彙の語が重なっても（「させていただく」と「せていただく」）、終わる位置が同じなら一回。
+ * 指摘が言う語は文の最初の出現のもの。同じ位置なら語彙表で先に書いた語（させていただく）。
+ */
+const usesIn = (sentence: Sentence, lexicon: Lexicon): Uses | undefined => {
+  const found = lexicon.map((entry) => ({ entry, ends: entryEnds(sentence, entry) })).filter(({ ends }) => ends.length > 0);
+  const first = found.toSorted((a, b) => Math.min(...a.ends) - Math.min(...b.ends))[0];
+  if (first === undefined) return undefined;
+  return { sentence, matched: first.entry.pattern, count: new Set(found.flatMap(({ ends }) => ends)).size };
+};
+
+/**
+ * 回数に上限がある語。数えるのは文ではなく出現で、一文に二度あれば二回。limit は許す回数で、それを超えたときだけ言う。
+ * message の「N 回まで」と同じ向き。指摘は出現のある文ごとに一つ。
+ */
 export const phraseCount: Detector = (doc, options): Finding[] => {
-  const hits = phraseHits(doc, options);
-  return hits.length <= options.limit ? [] : findingsOf(hits, options.limit);
+  const lexicon = options.lexicon ?? [];
+  const uses = inScope(doc, options.where).flatMap((sentence) => usesIn(sentence, lexicon) ?? []);
+  const total = uses.reduce((sum, use) => sum + use.count, 0);
+  if (total <= options.limit) return [];
+  return findingsOf(uses, options.limit, total);
 };