chaffjs 0.16.0 → 0.18.0

package/src/detectors/long-vowel.ts

@@ -0,0 +1,66 @@
+import type { Detector, Finding, OptionValue, ProseDocument, Sentence } from "../plugin.ts";
+import { isKatakanaWord, oddLongVowels, stemOf, type Ending, type KanaWord } from "../long-vowel.ts";
+import { nameSpans, touchesAny } from "../team-names.ts";
+
+const ENDINGS: readonly Ending[] = ["consistent", "drop", "keep"];
+
+const endingOf = (value: OptionValue | undefined): Ending => ENDINGS.find((ending) => ending === value) ?? "consistent";
+
+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;
+
+/** 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())));
+
+/**
+ * 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 (ディズニー).
+ */
+const kanaWordsOf = (sentence: Sentence, names: readonly string[], exempt: ReadonlySet<string>): KanaWord[] => {
+  const named = nameSpans(sentence.text, names);
+  return (sentence.tokens ?? [])
+    .filter((token) => token.pos === "NOUN" && isKatakanaWord(token.surface) && !exempt.has(stemOf(token.surface)))
+    .filter((token) => !touchesAny(named, token.span.start - sentence.span.start, token.span.end - sentence.span.start))
+    .map((token) => ({
+      surface: token.surface,
+      offset: token.span.start,
+      long: token.surface.endsWith("ー"),
+      dropped: token.features?.["LongVowelEnding"] === "Dropped",
+    }));
+};
+
+const quoteAt = (doc: ProseDocument, offset: number): string =>
+  doc.sentences.find((sentence) => sentence.span.start <= offset && offset < sentence.span.end)?.text.trim() ?? "";
+
+/**
+ * The final ー of katakana loanwords (コンピューター / コンピュータ). With no setting, it takes no side: it points at a word written
+ * both ways, and at the way the document writes less. Set to drop or keep, it points at every word the other way.
+ */
+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 words = doc.sentences.flatMap((sentence) => kanaWordsOf(sentence, doc.names ?? [], exempt));
+  const odd = oddLongVowels(words, endingOf(settings["ending"]), minMorae);
+  if (odd.length === 0 || odd.length < options.limit) return [];
+  return odd.map((entry) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc, entry.word.offset),
+    variant: entry.variant,
+    values: {
+      matched: entry.word.surface,
+      preferred: entry.preferred,
+      count: entry.count,
+      of: entry.of,
+      min_morae: minMorae,
+      limit: options.limit,
+      offset: entry.word.offset,
+    },
+  }));
+};

package/src/detectors/markup-finding.ts

@@ -0,0 +1,24 @@
+import type { Finding, Markup, ProseDocument, Span } from "../plugin.ts";
+
+// 記法の rule（見出し・画像・リンク・URL）が指摘を作る形。
+
+/** 引いて見せる記法の長さの上限。長い URL をまるごと見せても、どこが悪いかは伝わらない。 */
+const QUOTE_LIMIT = 80;
+
+export const quoteOf = (source: string, span: Span): string => {
+  const written = source.slice(span.start, span.end).replace(/\s+/gu, " ").trim();
+  return written.length > QUOTE_LIMIT ? `${written.slice(0, QUOTE_LIMIT)}…` : written;
+};
+
+export const findingAt = (doc: ProseDocument, span: Span, values: Readonly<Record<string, string | number>>, variant?: string): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: quoteOf(doc.source, span),
+  values: { ...values, offset: span.start },
+  ...(variant === undefined ? {} : { variant }),
+});
+
+/** Markdown の文書の記法。Markdown でなければ undefined。 */
+export const markupOf = (doc: ProseDocument): Markup | undefined => (doc.markup?.markdown === true ? doc.markup : undefined);

package/src/detectors/name-numeral.ts

@@ -1,14 +1,16 @@
+import { romanRangeOf } from "./roman-numeral.ts";
+
 /**
  * 大文字で始まる語のすぐ後ろの、I・V・X だけで書いたローマ数字（Engineer II、Leopold III、World War II）。名前に付く
  * 番号で、略語ではない。語の前に文字が無ければ（文の頭、箇条書きの番号の後ろ）、大文字は名前の印ではなく文頭の書き方なので
  * 外さない（Start IV fluids、1. Give IV fluids）。
- * CD、MD、DC、CI、MIX のように C・D・L・M を含む数字は略語であることが多いので、この位置でも略語のまま数える。
+ * 範囲（Reactions II-VI）も同じ。CD、MD、DC、CI、MIX のように C・D・L・M を含む数字は略語であることが多いので、この位置でも略語のまま数える。
  */
 
 type Span = { readonly start: number; readonly end: number };
 
 const SMALL_NUMERAL = "(?=[IVX])X{0,3}(?:IX|IV|V?I{0,3})";
-const NAMED_NUMERAL = new RegExp(String.raw`(?<![\p{L}\p{N}_])\p{Lu}\p{Ll}+\s+(?<numeral>${SMALL_NUMERAL})(?![\p{L}\p{N}_&])`, "gu");
+const NAMED_NUMERAL = new RegExp(String.raw`(?<![\p{L}\p{N}_])\p{Lu}\p{Ll}+\s+(?<numeral>${romanRangeOf(SMALL_NUMERAL)})(?![\p{L}\p{N}_&])`, "gu");
 const LETTER = /\p{L}/u;
 
 /** 文の中の、名前の後ろの番号の範囲（数字だけ）。 */

package/src/detectors/orthography.ts

@@ -1,8 +1,8 @@
 import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
-import { calendarRuns, type CalendarRun, type CalendarUnits } from "../calendar-number.ts";
+import { calendarRuns, calendarUnitsOf, type CalendarUnits } from "../calendar-number.ts";
 import { latinBoundaries, minorityStyle, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
-import { digitRunAround, isNumberName, sequenceLabelStarts } from "../number-name.ts";
+import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStarts, type NameContext } from "../number-name.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -32,32 +32,36 @@ const digitBeside = (boundary: Boundary): number => {
   return boundary.spaced ? boundary.offset + 1 : boundary.offset;
 };
 
-/** 文書全体で一度だけ読むもの。sequence は続き番号の行の頭、topUnits は都道府県の単位、calendar は日付・時刻の単位。 */
-type NumberContext = { readonly sequence: ReadonlySet<number>; readonly topUnits: ReadonlySet<string>; readonly calendar: CalendarUnits };
+/**
+ * 文書全体で一度だけ読むもの（number-name.ts の NameContext に加えて）。calendar は日付・時刻の単位、
+ * divisions は「第1節」のように「第」と番号の後ろに書く区切りの語。
+ */
+type NumberContext = NameContext & { readonly calendar: CalendarUnits; readonly divisions: ReadonlySet<string> };
 
-/** 文の中の日付・時刻の数の、並びの頭の位置と、日付の中の位置。 */
-const calendarPlaces = (sentence: Sentence, units: CalendarUnits): ReadonlyMap<number, CalendarRun["place"]> =>
-  new Map(calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run, place }) => [run.start, place]));
+/** 文の中の日付・時刻の数の、並びの頭の位置。 */
+const calendarStarts = (sentence: Sentence, units: CalendarUnits): ReadonlySet<number> =>
+  new Set(calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run }) => run.start));
 
 /**
- * 日付・時刻の中の境目（「9月」の数と単位のあいだ、「2026年9月」の年と 9 のあいだ）は、詰めて書く決まりで好みではない。
- * 日付の前の境目（「は 9月」の空白）は、数の前をどう空けるかという書き手の書き方なので数える。
+ * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目は、空け方の好みではないので数えない。
+ * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。
  */
-const isInsideCalendar = (boundary: Boundary, place: CalendarRun["place"] | undefined): boolean =>
-  place !== undefined && (boundary.kind === "after-digit" || place === "inner");
-
-/** 番号・識別子として書かれた数（number-name.ts）と日付・時刻の中の境目は、空け方の好みではないので数えない。 */
-const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlyMap<number, CalendarRun["place"]>): boolean => {
+const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlySet<number>): boolean => {
+  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));
   if (run === undefined) return true;
-  if (isInsideCalendar(boundary, calendar.get(run.start))) return false;
-  return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context.sequence, context.topUnits);
+  if (calendar.has(run.start)) return false;
+  return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context);
 };
 
 const patternList = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 const patternsOf = (doc: ProseDocument, id: string): ReadonlySet<string> => new Set(patternList(doc, id));
 
+/** 語彙表 numbered-label のうち、番号の position 側に書く語。 */
+const labelsAt = (doc: ProseDocument, position: "before" | "after"): ReadonlySet<string> =>
+  new Set((doc.lexicons["numbered-label"] ?? []).filter((entry) => entry.position === position).map((entry) => entry.pattern));
+
 /**
  * 鉤括弧で引いた題名や発言（「…ガイドライン ver. 1.1」）の中の境目。空け方は引いた元のもので、書き手の書き方ではない。
  * 括弧は日本語の字でも英数字でもないので、境目はまるごと括弧の中か外にある。
@@ -73,11 +77,13 @@ export const latinSpacing: Detector = (doc, options): Finding[] => {
   const context: NumberContext = {
     sequence: sequenceLabelStarts(doc.prose ?? doc.source),
     topUnits: patternsOf(doc, "prefecture-unit"),
-    calendar: { chained: patternList(doc, "date-time-unit"), positional: patternsOf(doc, "calendar-unit"), year: patternsOf(doc, "calendar-year-unit") },
+    labelWords: labelsAt(doc, "before"),
+    calendar: calendarUnitsOf(doc),
+    divisions: labelsAt(doc, "after"),
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);
-    const calendar = calendarPlaces(sentence, context.calendar);
+    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))
       .map((boundary) => ({ sentence, ...boundary }));

package/src/detectors/oxford-comma.ts

@@ -0,0 +1,297 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+import {
+  contentCount,
+  exampleEnd,
+  firstAt,
+  firstContent,
+  firstNoun,
+  hasAdposition,
+  hasContent,
+  hasDeterminer,
+  hasListConjunction,
+  hasParticiple,
+  hasVerb,
+  isClause,
+  isModifiedNoun,
+  isModifier,
+  isParticiple,
+  isPluralNounPhrase,
+  itemAfter,
+  lastContent,
+  lastNoun,
+  leadShape,
+  openingKind,
+  openingOf,
+  participleOpening,
+  shapeOf,
+} from "./list-item.ts";
+import { listReader, type ItemList } from "./list-items.ts";
+import { APPOSITIVE_ANCHOR, isListConjunction, listSentenceOf, VERBAL, type ItemScope, type ListWords } from "./list-sentence.ts";
+import {
+  after,
+  contentOnlyWith,
+  every,
+  findAfterFirst,
+  findLast,
+  firstOf,
+  lastOf,
+  sameShapes,
+  secondLastOf,
+  secondOf,
+  sizeOf,
+  some,
+  wholeList,
+  withoutFirst,
+  type View,
+} from "./list-view.ts";
+import { lowerBound, type TokenRange } from "./token-column.ts";
+
+const EMPTY: TokenRange = { start: 0, end: 0 };
+
+const commaBefore = (scope: ItemScope, at: number): boolean => scope.sentence.tokens[at - 1]?.surface === ",";
+
+/**
+ * 導入の句（After the review, / If it fails, / Finally, / To test it, / Based on the review,）は並列の項目ではない。
+ * 節の最初の項目が前置詞・接続詞・副詞・to・過去分詞で始まり、次の項目と頭の形が違えば外す。
+ * Quickly, quietly and carefully は残る。For managers, engineers and designers, も外れるが、前置詞のあとの名詞を
+ * 項目と読むと、Over this period, the subcommittees and the full committee ... を並びと誤る。こちらのほうが多い。
+ */
+const LEAD_POS = new Set(["ADP", "SCONJ", "ADV", "PART"]);
+
+const withoutLead = (view: View): View => {
+  const { scope } = view.list;
+  const [first, second] = [firstOf(view), secondOf(view)];
+  const opening = first === undefined ? undefined : openingOf(scope, first.item);
+  if (first === undefined || second === undefined || opening === undefined) return view;
+  if (!LEAD_POS.has(opening.pos) && !isParticiple(opening)) return view;
+  return openingKind(scope, first.item) === openingKind(scope, second.item) ? view : withoutFirst(view);
+};
+
+/**
+ * and / or で始まる項目で、前の並びは閉じている（offering, giving, or receiving, directly or indirectly）。
+ * 次の並びはその項目から始まる。項目が動詞で始まれば、その目的語から（Develop, maintain, and track courses, materials and events）。
+ * 項目が残らなければ、後ろは新しい句の頭。導入の句（directly or indirectly,）を外す。
+ */
+const afterClosedList = (view: View): View => {
+  const closing = findLast(view, "closed");
+  if (closing === undefined) return view;
+  const { scope } = view.list;
+  const conjunction = firstAt(scope, "conjunction", closing.item);
+  const body = { start: conjunction === -1 ? closing.item.start : conjunction + 1, end: closing.item.end };
+  const head = firstAt(scope, "content", body);
+  const rest = VERBAL.has(scope.sentence.tokens[head]?.pos ?? "") ? { start: head + 1, end: body.end } : body;
+  return hasContent(scope, rest) ? { ...after(view, closing), pre: rest } : withoutLead(after(view, closing));
+};
+
+/**
+ * 例の句（such as / including / e.g.）のあとが並び。句の前の項目は並びではない（the screen lock on your phone, such as a PIN or
+ * phone-based fingerprint は 2 つ）。句の中の項目の形が揃わなければ句で切らない（materials such as green steel, utilizing ..., and
+ * adopting ... / (e.g., by location, contract type, or contract preference)）。句の中に and / or があれば句はもう閉じていて、
+ * 句ごと 1 つの項目（apples, oranges such as navels and mandarins, and pears）。
+ */
+const fromExample = (view: View): View => {
+  const phrase = findLast(view, "example");
+  if (phrase === undefined) return view;
+  const { scope } = view.list;
+  const examples = { start: exampleEnd(scope, phrase.item), end: phrase.item.end };
+  if (hasListConjunction(scope, examples)) return view;
+  const inPhrase = contentOnlyWith(after(view, phrase), examples);
+  return sameShapes(inPhrase) ? inPhrase : view;
+};
+
+/** 解析器は過去形と過去分詞（fixed）を見分けられない。動詞のある項目のあとの「過去分詞」の並びは、述語の並びと読む。 */
+const pastPredicates = (scope: ItemScope, first: TokenRange, form: string, afterItem: TokenRange): boolean =>
+  form === "Part" && participleOpening(scope, afterItem)?.form === "Part" && hasVerb(scope, first);
+
+/**
+ * 最初より後ろの項目が分詞で始まるとき。最初の項目にも同じ形の分詞があれば分詞の並び
+ * （are hiring engineers, buying laptops and renting desks / Tested, reviewed and approved）。後ろの項目が動詞で始まれば述語の並びで、
+ * 分詞は解析器の読み違い（the jury, cross-examined the witnesses, presented witnesses, and made）。そうでなければ分詞の句
+ * （from Latin, meaning ship or boat / the judge, sitting without a jury, and sentenced）で、並びがあるならその句の中から始まる。
+ * 分詞より前の項目と分詞そのものは項目ではない（programs, including the office, the desk and the team）。句の中の項目の形が揃わなければ
+ * 句は挿入で、並びは句の後ろだけ（relief, including an injunction, in any court ... and without / including before the date, to a
+ * Recipient ... “confidential”, “proprietary”, or the like）。
+ */
+const fromParticiplePhrase = (view: View, afterItem: TokenRange): View => {
+  const { scope } = view.list;
+  const [first, phrase] = [firstOf(view), findAfterFirst(view, "participle")];
+  const opening = phrase === undefined ? undefined : participleOpening(scope, phrase.item);
+  if (first === undefined || phrase === undefined || opening === undefined) return view;
+  const rest = after(view, phrase);
+  const predicates = some(rest, "verbalShape") || pastPredicates(scope, first.item, opening.form, afterItem);
+  if (hasParticiple(scope, first.item, opening.form) || predicates) return view;
+  const inPhrase = withoutLead(contentOnlyWith(rest, { start: opening.at + 1, end: phrase.item.end }));
+  return sameShapes(inPhrase) ? inPhrase : rest;
+};
+
+/**
+ * 名詞のすぐ後ろの、読点で挟まれた X and Y は同格（two HPV types, HPV16 and HPV18, that account / Governments, both state and
+ * federal, spend）。項目が 2 つに見え、and の前に読点が無く、and の後ろの項目が読点で閉じ、後ろの 2 つに動詞が無いときに同格と読む。
+ * 2 つを結ぶ同格に Oxford comma は打たないので、and の前に読点があれば 3 つの並び（the subcommittee, full committee, and
+ * chamber levels, as well as）。読点の無い本当の並び（apples, pears and plums, then ...）はこの形と見分けられず、判定から外れる。
+ * 閉じた読点のあとに and / or が続くなら、並びのあとに節をつないでいる（apples, pears and plums, and went home）。
+ */
+const isAppositive = (scope: ItemScope, at: number, view: View, afterItem: TokenRange): boolean => {
+  const [anchor, head] = [firstOf(view), secondOf(view)];
+  if (sizeOf(view) !== 2 || anchor === undefined || head === undefined || commaBefore(scope, at)) return false;
+  const end = afterItem.end;
+  const joinsClause = isListConjunction(scope.sentence.tokens[end + 1]);
+  const closed = scope.sentence.tokens[end]?.surface === "," && scope.sentence.depths[end] === scope.sentence.depths[at] && !joinsClause;
+  return closed && APPOSITIVE_ANCHOR.has(lastContent(scope, anchor.item)?.pos ?? "") && !hasVerb(scope, head.item) && !hasVerb(scope, afterItem);
+};
+
+/**
+ * and の後ろの項目に読点と、同じ形の項目を連れた and / or が続くなら、この and は項目の中にある（searches and seizures, and
+ * the Eighth's ban）。頭の形か、節かどうかが違えば別の節をつなぐ and で、この and までが並び（apples, pears and plums, and went home / and figs fell）。
+ */
+const listContinues = (scope: ItemScope, afterItem: TokenRange): boolean => {
+  const next = afterItem.end;
+  if (scope.sentence.tokens[next]?.surface !== "," || !isListConjunction(scope.sentence.tokens[next + 1])) return false;
+  const following = itemAfter(scope, next + 1);
+  const shape = leadShape(scope, following);
+  return shape !== undefined && shape === leadShape(scope, afterItem) && isClause(scope, following) === isClause(scope, afterItem);
+};
+
+/**
+ * 語のあとが複数形の名詞句なら、語は名詞にかかる語で、2 つはもう揃っている（the renderer in both modes and the exporter）。
+ * and の後ろも冠詞の無い複数形の名詞句なら、2 つを結ぶ語（both project goals and business goals）。
+ */
+const pairComplete = (scope: ItemScope, member: TokenRange, afterItem: TokenRange): boolean => {
+  const end = firstAt(scope, "conjunction", afterItem);
+  const partner = end === -1 ? afterItem : { start: afterItem.start, end };
+  return isPluralNounPhrase(scope, member) && !(isPluralNounPhrase(scope, partner) && !hasDeterminer(scope, partner));
+};
+
+/**
+ * 最後の項目に 2 つだけを結ぶ語（between / either）があり、この接続詞がその語の相手で（between … and / either … or）、そのあとに
+ * and / or がまだ無く、読点も無ければ、この and / or はその 2 つを結ぶ（the Key Terms between Provider and Customer, and any policies）。
+ * 相手でなければ語は名詞にかかるだけ（the impact of either option and implementation）。括弧の中の語は外の接続詞と組まない。
+ */
+const pairsInLastItem = (scope: ItemScope, at: number, view: View, afterItem: TokenRange): boolean => {
+  const last = lastOf(view)?.item ?? EMPTY;
+  const conjunction = scope.sentence.tokens[at]?.surface.toLowerCase() ?? "";
+  const openers = scope.sentence.pairOpeners.get(conjunction)?.get(scope.sentence.depths[at] ?? 0) ?? [];
+  const opener = openers[lowerBound(openers, last.end) - 1] ?? -1;
+  if (opener < last.start || commaBefore(scope, at)) return false;
+  const member = { start: opener + 1, end: last.end };
+  return !pairComplete(scope, member, afterItem) && !hasListConjunction(scope, member);
+};
+
+/**
+ * 修飾語 1 つだけの項目と、修飾語で始まる名詞句を結ぶ and / or は、2 つの修飾語が名詞を共有している（natural and artificial flavor /
+ * registered or certified mail）。前の項目も修飾語で終われば、修飾語の並び（red, white and blue flags）。and / or の前に読点があれば、
+ * 項目の区切り（Federal government, military, and agricultural workers）。
+ */
+const sharesNoun = (scope: ItemScope, at: number, view: View, afterItem: TokenRange): boolean => {
+  const [previous, last] = [secondLastOf(view), lastOf(view)];
+  if (commaBefore(scope, at) || previous === undefined || last === undefined || contentCount(scope, last.item) !== 1) return false;
+  return isModifier(firstContent(scope, last.item)) && !isModifier(lastContent(scope, previous.item)) && isModifiedNoun(scope, afterItem);
+};
+
+/**
+ * and / or の後ろの最初の名詞が、最後の項目の前置詞の目的語と同じ品詞で、どの項目の頭とも違う（chat in Slack or Google Hangouts /
+ * Teams (beta): 固有名詞どうし）。頭と同じ品詞なら項目とも読める（petitions for waivers and appeals）ので、並びのまま。
+ */
+const likeLastObject = (scope: ItemScope, view: View, afterItem: TokenRange): boolean => {
+  const kind = firstNoun(scope, afterItem)?.pos;
+  if (kind === undefined) return false;
+  return lastNoun(scope, lastOf(view)?.item ?? EMPTY)?.pos === kind && every(view, kind === "NOUN" ? "notNounHead" : "notProperNounHead");
+};
+
+/**
+ * どの項目も前置詞の句を連れ、and / or の後ろだけが連れておらず、その目的語に似ていれば、and / or は最後の項目の前置詞の目的語を結ぶ
+ * （updates on the Google Doc, chat in Slack or Google Hangouts は 2 つ）。and / or の前に読点があれば、項目の区切りなので並び。
+ */
+const joinsObjects = (scope: ItemScope, at: number, view: View, afterItem: TokenRange): boolean =>
+  !commaBefore(scope, at) &&
+  every(view, "prepositionalTail") &&
+  !hasAdposition(scope, afterItem) &&
+  !hasVerb(scope, afterItem) &&
+  likeLastObject(scope, view, afterItem);
+
+/** and / or が並びの最後の継ぎ目ではなく、最後の項目の中にある。 */
+const insideLastItem = (scope: ItemScope, at: number, view: View, afterItem: TokenRange): boolean =>
+  pairsInLastItem(scope, at, view, afterItem) || sharesNoun(scope, at, view, afterItem) || joinsObjects(scope, at, view, afterItem);
+
+/**
+ * 節を並べるなら、どの項目も節。Additionally, others can learn, and the mistake is rarer. の Additionally は項目ではなく、
+ * and の前の読点は節をつなぐ読点。名詞の並びは最初の項目に前置き（We shipped the parser）を抱えるので、この確かめは節の並びだけにする。
+ * and の後ろだけが節なのは主語の並び（The parser, the renderer and the exporter shipped.）なので外さない。
+ * 動詞で始まる項目を並べるなら、どの項目にも動詞がある。The scope, in contrast, is larger, and covers ... の The scope は項目ではない。
+ */
+const itemsAgree = (scope: ItemScope, view: View, afterItem: TokenRange, shape: string): boolean => {
+  const last = lastOf(view);
+  const clausesAgree = last === undefined || !isClause(scope, last.item) || (isClause(scope, afterItem) && every(view, "isClause"));
+  return clausesAgree && (!VERBAL.has(shape) || every(view, "hasVerb"));
+};
+
+/**
+ * 読点で区切った項目が and / or の前に 2 つ以上あり、最後の項目と and の後ろが同じ形のときだけ並列。
+ * 導入の読点（After the review, the team fixed the bug and shipped it.）や、節をつなぐ読点
+ * （We tested it, and the team shipped it.）は、Oxford comma を打つかどうかの選択を見せない。
+ * 題名の読点は題名を付けた人のもの。書き手の流儀の票にしない。
+ */
+const listAt = (list: ItemList, at: number): boolean | undefined => {
+  const { scope } = list;
+  const afterItem = itemAfter(scope, at);
+  const items = fromParticiplePhrase(fromExample(afterClosedList(withoutLead(wholeList(list)))), afterItem);
+  if (listContinues(scope, afterItem) || isAppositive(scope, at, items, afterItem) || insideLastItem(scope, at, items, afterItem)) return undefined;
+  const last = lastOf(items);
+  const shape = last === undefined ? undefined : shapeOf(scope, last.item);
+  if (sizeOf(items) < 2 || shape === undefined || shape !== shapeOf(scope, afterItem)) return undefined;
+  return itemsAgree(scope, items, afterItem, shape) ? commaBefore(scope, at) : undefined;
+};
+
+const isJudgedConjunction = (token: Token, at: number): boolean => at > 0 && isListConjunction(token);
+
+/**
+ * 文の and / or ごとの、並びの判定（読点を打てば true、打たなければ false、並びでなければ undefined）。文は一度だけ読み、
+ * 項目は and / or の位置まで読み進めた並びから取る。
+ */
+export const listVerdicts = (tokens: readonly Token[], words: ListWords, source: string): (boolean | undefined)[] => {
+  if (!tokens.some(isJudgedConjunction)) return [];
+  const sentence = listSentenceOf(tokens, words, source);
+  const readItems = listReader(sentence);
+  return tokens.flatMap((token, at) => {
+    if (!isJudgedConjunction(token, at)) return [];
+    return [sentence.inCitedTitle(at) ? undefined : listAt(readItems(at), at)];
+  });
+};
+
+/**
+ * 3 つ以上の並列の最後の and / or の前に読点を打つか。Oxford comma。
+ *
+ * どちらが正しいかは決めない。スタイルガイドで割れる論点に立場を取ると rule ごと無視される。
+ * 見るのは 1 つの文書で揃っているかだけ。spec §12.3。最初に判定できた並びで決める。
+ */
+const oxfordIn = (tokens: readonly Token[], words: ListWords, source: string): boolean | undefined =>
+  listVerdicts(tokens, words, source).find((verdict) => verdict !== undefined);
+
+const patternsOf = (lexicon: Lexicon | undefined): ReadonlySet<string> => new Set((lexicon ?? []).map((entry) => entry.pattern.toLowerCase()));
+
+export const oxfordComma: Detector = (doc, options): Finding[] => {
+  const words = {
+    participle: patternsOf(doc.lexicons["participle-word"]),
+    example: doc.lexicons["example-marker"] ?? [],
+    pair: patternsOf(doc.lexicons["pair-opener"]),
+  };
+  const judged = doc.sentences.flatMap((sentence) => {
+    const oxford = oxfordIn(sentence.tokens ?? [], words, doc.source);
+    return oxford === undefined ? [] : [{ sentence, oxford }];
+  });
+  const withComma = judged.filter((entry) => entry.oxford).length;
+  const minorityUsesComma = withComma <= judged.length - withComma;
+  const few = minorityUsesComma ? withComma : judged.length - withComma;
+  // 同数なら少数派は無い。
+  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
+  return judged
+    .filter((entry) => entry.oxford === minorityUsesComma)
+    .map(({ sentence }) => ({
+      rule: "oxford-comma-consistency",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { count: few, limit: options.limit, offset: sentence.span.start },
+    }));
+};

package/src/detectors/place-run.ts

@@ -20,10 +20,13 @@ type Run = { readonly tokens: readonly Token[]; readonly last: number; readonly
  * 閉じれば、そこまでが 1 つの地名。連なりの外（「に」「の」も 1 字）までは読まない。
  */
 const closedByUnit = (run: Run, index: number): boolean => {
-  const token = run.tokens[index];
-  if (index > run.last || token === undefined) return false;
-  if (isGeoUnit(token)) return !run.topUnits.has(token.surface);
-  return isNamePiece(token) && closedByUnit(run, index + 1);
+  for (let at = index; at <= run.last; at += 1) {
+    const token = run.tokens[at];
+    if (token === undefined) return false;
+    if (isGeoUnit(token)) return !run.topUnits.has(token.surface);
+    if (!isNamePiece(token)) return false;
+  }
+  return false;
 };
 
 /**

package/src/detectors/placeholder-text.ts

@@ -0,0 +1,27 @@
+import type { Lexicon } from "../plugin.ts";
+
+type Span = { readonly start: number; readonly end: number };
+
+/** 雛形の空欄を囲む括弧。記号の形で、どの言語でも同じ。 */
+const BRACKETED = /\[([^[\]\n]{1,60})\]|【([^【】\n]{1,30})】|［([^［］\n]{1,30})］/gu;
+
+/**
+ * 括弧のすぐ後ろ。Markdown のリンク（[text](url)、[text][ref]）と参照の定義（[ref]: url）、
+ * 値が続く見出しの札（【氏名】山田、【日付】2024年）は空欄ではない。助詞（【会社名】の）や空白・句読点が続くなら空欄。
+ */
+const FILLED_AFTER = /^[([:：\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}]/u;
+
+const innerOf = (match: RegExpExecArray): string => (match[1] ?? match[2] ?? match[3] ?? "").trim().toLowerCase();
+
+/** 括弧の中身が語彙表の語そのものか、その語で始まって空白・アポストロフィが続くか（[Your Name]、[Insert Date]）。 */
+const holdsWord = (inner: string, words: Lexicon): boolean =>
+  words.some((word) => {
+    const pattern = word.pattern.toLowerCase();
+    return inner === pattern || (inner.startsWith(pattern) && /^[\s'’]/u.test(inner.slice(pattern.length)));
+  });
+
+/** 文の中の、埋め忘れた雛形の空欄（[Your Name]、【会社名】）の範囲。words は空欄に書く語。 */
+export const placeholderSpans = (text: string, words: Lexicon): Span[] =>
+  [...text.matchAll(BRACKETED)]
+    .filter((match) => !FILLED_AFTER.test(text.slice(match.index + match[0].length)) && holdsWord(innerOf(match), words))
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/detectors/quote-around.ts

@@ -0,0 +1,9 @@
+/** 見せる前後の字数。記号 1 つの指摘は、周りの言葉が無いとどこか分からない。 */
+const QUOTE_REACH = 20;
+
+/** text の start から end の前後を、空白をならして引く。 */
+export const quoteAround = (text: string, start: number, end: number = start + 1): string =>
+  text
+    .slice(Math.max(0, start - QUOTE_REACH), end + QUOTE_REACH)
+    .replace(/\s+/gu, " ")
+    .trim();

package/src/detectors/register.ts

@@ -15,21 +15,32 @@ const chainAtEnd = (preceding: readonly Token[]): readonly Token[] => {
   return preceding.slice(Math.max(head, 0));
 };
 
+/** 語彙表 neutral-ending の語（「こと」）か。書いた形か原形で照らす。 */
+const isNeutralWord = (token: Token | undefined, neutral: readonly LexiconEntry[]): boolean =>
+  token !== undefined && neutral.some((entry) => token.surface === entry.pattern || token.lemma === entry.pattern);
+
 /**
- * 非自立名詞で終わる文末は、手前の述語の連なりまで見る。「予約できること。」「おかけしましたこと。」は手前の述語が調子を持つ。
- * 要件や規程のである調は「〜こと。」で書く。「以下のとおり。」は手前も述語でないので、調子を持たないまま。
+ * 非自立名詞で終わる文末は、手前の述語の連なりまで見る。「使っているのかな？」は手前の述語が調子を持つ。
+ * 「以下のとおり。」は手前も述語でないので、調子を持たないまま。
+ * 語彙表 neutral-ending の語（「こと」）で終わる文末は手前を見ない。「〜を保持すること。」は体言止めで、要件や規程の箇条書きは
+ * ですます調の文書でもである調の文書でもこの形で書く。
  */
-const withPreceding = (ending: readonly Token[], preceding: readonly Token[]): readonly Token[] =>
-  isDependent(ending[0]) ? [...chainAtEnd(preceding), ...ending] : ending;
+const withPreceding = (ending: readonly Token[], preceding: readonly Token[], neutral: readonly LexiconEntry[]): readonly Token[] =>
+  isDependent(ending[0]) && !isNeutralWord(ending[0], neutral) ? [...chainAtEnd(preceding), ...ending] : ending;
 
 /**
- * 文末の語の調子。preceding は文末の語より前の語。
+ * 文末の語の調子。preceding は文末の語より前の語。neutral は調子を持たない文末の語（語彙表 neutral-ending）。
  * 文末に述語（動詞・形容詞・助動詞）が無ければ、ですます調でもである調でもないので undefined。
  * 「以下の通り。」「円錐形の麦わら帽子。」のような名詞で終わる文を数えると、そのままである調の少数派になっていた。
  * 書いた形でも原形でも読みでも当てる（polite-word.ts）。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
  */
-export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly LexiconEntry[]): Register | undefined => {
-  const judged = withPreceding(ending, preceding);
+export const registerOf = (
+  ending: readonly Token[],
+  preceding: readonly Token[],
+  polite: readonly LexiconEntry[],
+  neutral: readonly LexiconEntry[] = [],
+): Register | undefined => {
+  const judged = withPreceding(ending, preceding, neutral);
   if (!judged.some(isPredicate)) return undefined;
   return judged.some((token) => isPoliteWord(token, polite)) ? "polite" : "plain";
 };
@@ -56,21 +67,36 @@ export const groupOf = (offset: number, lists: readonly Span[], runs: readonly S
 /** group: 文が入っているまとまり（groupOf の値）。本文なら undefined。 */
 export type Judged = { readonly register: Register; readonly group: number | undefined };
 
-/** 混ざった文と、その文が属する本文または箇条書きの中の少数派の数。 */
+/** 混ざった文と、その文が属するまとまり（本文、または箇条書き 1 つ）の中の少数派の数。文書全体の数ではない。 */
 export type Slip<T extends Judged> = { readonly entry: T; readonly count: number };
 
 const countIn = (judged: readonly Judged[], register: Register): number => judged.filter((entry) => entry.register === register).length;
 
+/** 多いほう。同数なら undefined。 */
+export const majorityOf = (judged: readonly Judged[]): Register | undefined => {
+  const difference = countIn(judged, "polite") - countIn(judged, "plain");
+  if (difference === 0) return undefined;
+  return difference > 0 ? "polite" : "plain";
+};
+
 /** 少ないほう。同数なら文書全体で少ないほう、それも同数なら丁寧体。 */
 const minorityOf = (group: readonly Judged[], whole: readonly Judged[]): Register => {
-  const difference = countIn(group, "polite") - countIn(group, "plain");
-  if (difference !== 0) return difference < 0 ? "polite" : "plain";
+  const majority = majorityOf(group);
+  if (majority !== undefined) return majority === "polite" ? "plain" : "polite";
   return countIn(whole, "polite") <= countIn(whole, "plain") ? "polite" : "plain";
 };
 
+/**
+ * 箇条書きの中の少数派が、文書全体では多数派か。それなら箇条書きの中で文書の調子に寄せた側なので、直す側ではない。
+ * 常体の多い箇条書きにですます調の文が混ざっても、ですます調の文書なら「多いほうに揃えて」は文書の少数派へ揃えることになる。
+ */
+export const followsDocument = (group: number | undefined, minority: Register, whole: readonly Judged[]): boolean =>
+  group !== undefined && majorityOf(whole) === minority;
+
 const slipsInGroup = <T extends Judged>(judged: readonly T[], group: number | undefined, limit: number): Slip<T>[] => {
   const members = judged.filter((entry) => entry.group === group);
   const minority = minorityOf(members, judged);
+  if (followsDocument(group, minority, judged)) return [];
   const slips = members.filter((entry) => entry.register === minority);
   // 片方しか無ければ揃っている。少数派が閾値を超えて多ければ、混在ではなく別の文体。
   if (slips.length === 0 || slips.length > limit) return [];
@@ -80,6 +106,7 @@ const slipsInGroup = <T extends Judged>(judged: readonly T[], group: number | un
 /**
  * 調子が混ざった文を、judged の順で。本文は本文どうし、箇条書きと番号で始まる段落の並びは 1 つずつ、その中で揃っているかを見る。
  * ですます調の本文に常体の箇条書きを置くのはよくある書き方で、箇条書きが丸ごと揃っていれば混在ではない。
+ * 箇条書きの中で混ざっていても、少数派が文書全体の多数派なら指さない（followsDocument）。
  */
 export const slipsOf = <T extends Judged>(judged: readonly T[], limit: number): Slip<T>[] => {
   const slips = [...new Set(judged.map((entry) => entry.group))].flatMap((group) => slipsInGroup(judged, group, limit));

package/src/detectors/roman-numeral.ts

@@ -3,3 +3,6 @@
  * 各桁が省けるので空文字にも当たる。1 文字目があることを先読みで求める。
  */
 export const ROMAN_NUMERAL = "(?=[MDCLXVI])M{0,4}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})";
+
+/** ハイフンかダッシュで繋いだ数字の範囲（II-VI、I–III）も、一つの番号として読む。 */
+export const romanRangeOf = (numeral: string): string => `${numeral}(?:[-–]${numeral})?`;