chaffjs 0.15.0 → 0.17.0

package/src/detectors/orthography.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { calendarRuns, calendarUnitsOf, type CalendarRun, 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";
@@ -31,13 +32,32 @@ const digitBeside = (boundary: Boundary): number => {
   return boundary.spaced ? boundary.offset + 1 : boundary.offset;
 };
 
-/** 番号・識別子として書かれた数の境目は、空け方の好みではないので数えない（number-name.ts）。 */
-const isCounted = (sentence: Sentence, boundary: Boundary, sequence: ReadonlySet<number>, topUnits: ReadonlySet<string>): boolean => {
+/** 文書全体で一度だけ読むもの。sequence は続き番号の行の頭、topUnits は都道府県の単位、calendar は日付・時刻の単位。 */
+type NumberContext = { readonly sequence: ReadonlySet<number>; readonly topUnits: ReadonlySet<string>; readonly calendar: CalendarUnits };
+
+/** 文の中の日付・時刻の数の、並びの頭の位置と、日付の中の位置。 */
+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]));
+
+/**
+ * 日付・時刻の中の境目（「9月」の数と単位のあいだ、「2026年9月」の年と 9 のあいだ）は、詰めて書く決まりで好みではない。
+ * 日付の前の境目（「は 9月」の空白）は、数の前をどう空けるかという書き手の書き方なので数える。
+ */
+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 => {
   if (boundary.kind === "letter") return true;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
-  return run === undefined || !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, sequence, topUnits);
+  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);
 };
 
+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));
+
 /**
  * 鉤括弧で引いた題名や発言（「…ガイドライン ver. 1.1」）の中の境目。空け方は引いた元のもので、書き手の書き方ではない。
  * 括弧は日本語の字でも英数字でもないので、境目はまるごと括弧の中か外にある。
@@ -50,12 +70,16 @@ const isQuoted = (quoted: readonly Span[], boundary: Boundary): boolean => isWit
  */
 export const latinSpacing: Detector = (doc, options): Finding[] => {
   // 覆った文（prose）で探す。コードの中の「1 件」は並びに入れない。
-  const sequence = sequenceLabelStarts(doc.prose ?? doc.source);
-  const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
+  const context: NumberContext = {
+    sequence: sequenceLabelStarts(doc.prose ?? doc.source),
+    topUnits: patternsOf(doc, "prefecture-unit"),
+    calendar: calendarUnitsOf(doc),
+  };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);
+    const calendar = calendarPlaces(sentence, context.calendar);
     return latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
-      .filter((boundary) => !isQuoted(quoted, boundary) && isCounted(sentence, boundary, sequence, topUnits))
+      .filter((boundary) => !isQuoted(quoted, boundary) && isCounted(sentence, boundary, context, calendar))
       .map((boundary) => ({ sentence, ...boundary }));
   });
   return KINDS.flatMap((kind) => {

package/src/detectors/oxford-comma.ts

@@ -0,0 +1,402 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+
+const LIST_CONJUNCTION = new Set(["and", "or"]);
+
+const isComma = (token: Token): boolean => token.surface === ",";
+
+const commaBefore = (tokens: readonly Token[], at: number): boolean => tokens[at - 1]?.surface === ",";
+
+/** 並列はこれをまたがない。セミコロンの前後は別の節。 */
+const CLAUSE_BREAK = new Set([";", ":", "—"]);
+
+/** 各 token の前で閉じていない括弧の数。括弧の中の読点（external users (e.g., guests), and ...）は外の並列を切らない。 */
+const PAREN_STEP: Readonly<Record<string, number>> = { "(": 1, ")": -1 };
+
+const depthsOf = (tokens: readonly Token[]): number[] =>
+  tokens.reduce<{ depths: number[]; open: number }>(
+    (acc, token) => ({ depths: [...acc.depths, acc.open], open: Math.max(0, acc.open + (PAREN_STEP[token.surface] ?? 0)) }),
+    { depths: [], open: 0 },
+  ).depths;
+
+/**
+ * 並びを読むための語彙表。participle は解析器が分詞と読まないが読点のあとで分詞の句を始める語（meaning）、
+ * example は例を挙げる句（such as, e.g.）、pair は 2 つだけを結ぶ語とその接続詞（between and / either or）。
+ */
+type ListWords = { readonly participle: ReadonlySet<string>; readonly example: Lexicon; readonly pair: ReadonlySet<string> };
+
+type Clause = { readonly tokens: readonly Token[]; readonly depths: readonly number[]; readonly words: ListWords };
+
+/** 冠詞や引用符を飛ばした、項目の頭の品詞。the parser と an exporter と samples を同じ形と見る。 */
+const NOMINAL = new Set(["NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
+
+const isContent = (token: Token): boolean => token.pos !== "DET" && token.pos !== "PUNCT" && token.pos !== "X";
+
+const shapeOf = (item: readonly Token[]): string | undefined => {
+  const head = item.find(isContent);
+  if (head === undefined) return undefined;
+  return NOMINAL.has(head.pos) ? "NOMINAL" : head.pos;
+};
+
+const VERBAL = new Set(["VERB", "AUX"]);
+
+/** 主語と述語のある項目。the team fixed the bug / these are crucial。gets us more は述語だけ。 */
+const isClause = (item: readonly Token[]): boolean => {
+  const first = item.find((token) => token.pos !== "PUNCT" && token.pos !== "X");
+  if (first === undefined || !(first.pos === "DET" || NOMINAL.has(first.pos))) return false;
+  return item.some((token) => token !== first && VERBAL.has(token.pos));
+};
+
+/** 節の頭から and / or の手前までを、同じ深さの読点で項目に切る。Oxford comma の読点のあとは空なので項目にならない。 */
+const itemsBefore = (clause: Clause, at: number): Token[][] => {
+  const level = clause.depths[at] ?? 0;
+  const start = clause.tokens.slice(0, at).findLastIndex((token) => CLAUSE_BREAK.has(token.surface)) + 1;
+  return clause.tokens
+    .slice(start, at)
+    .reduce<Token[][]>(
+      (items, token, offset) => {
+        if (isComma(token) && clause.depths[start + offset] === level) return [...items, []];
+        return [...items.slice(0, -1), [...(items.at(-1) ?? []), token]];
+      },
+      [[]],
+    )
+    .filter((item) => item.length > 0);
+};
+
+/**
+ * and / or で始まる項目で、前の並びは閉じている（offering, giving, or receiving, directly or indirectly）。
+ * 次の並びはその項目から始まる。項目が動詞で始まれば、その目的語から（Develop, maintain, and track courses, materials and events）。
+ */
+const afterClosedList = (items: readonly Token[][]): Token[][] => {
+  const closed = items.findLastIndex((item) => LIST_CONJUNCTION.has(openingOf(item)?.surface.toLowerCase() ?? ""));
+  const closing = items[closed];
+  if (closing === undefined) return [...items];
+  const body = closing.slice(closing.findIndex((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase())) + 1);
+  const head = body.findIndex(isContent);
+  const rest = VERBAL.has(body[head]?.pos ?? "") ? body.slice(head + 1) : body;
+  // 項目が残らなければ、後ろは新しい句の頭。導入の句（directly or indirectly,）を外す。
+  return rest.some(isContent) ? [rest, ...items.slice(closed + 1)] : [...withoutLead(items.slice(closed + 1))];
+};
+
+/** and / or の後ろの項目。次の読点か節の切れ目まで。 */
+const itemAfter = (tokens: readonly Token[], at: number): Token[] => {
+  const end = tokens.findIndex((token, index) => index > at && (isComma(token) || CLAUSE_BREAK.has(token.surface)));
+  return tokens.slice(at + 1, end === -1 ? undefined : end);
+};
+
+/**
+ * 導入の句（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 isParticiple = (token: Token): boolean => token.features?.["VerbForm"] === "Part";
+
+const openingOf = (item: readonly Token[]): Token | undefined => item.find((token) => token.pos !== "PUNCT" && token.pos !== "X");
+
+const openingKind = (item: readonly Token[]): string | undefined => {
+  const opening = openingOf(item);
+  return opening !== undefined && isParticiple(opening) ? "PARTICIPLE" : shapeOf(item);
+};
+
+const withoutLead = (items: readonly Token[][]): readonly Token[][] => {
+  const [first, second] = items;
+  const opening = first === undefined ? undefined : openingOf(first);
+  if (first === undefined || second === undefined || opening === undefined) return items;
+  if (!LEAD_POS.has(opening.pos) && !isParticiple(opening)) return items;
+  return openingKind(first) === openingKind(second) ? items : items.slice(1);
+};
+
+/**
+ * 形容詞のあとの読点は、名詞の前で形容詞を重ねているだけのことが多い（the long, winding bridge）。
+ * 次の項目が名詞で終わるならつなげ直す。形容詞そのものの並び（quick, cheap and reliable）は切ったまま。
+ */
+const lastContent = (item: readonly Token[]): Token | undefined => item.findLast(isContent);
+
+const joinAdjectives = (items: readonly Token[][]): Token[][] =>
+  items.reduce<Token[][]>((joined, item) => {
+    const previous = joined.at(-1);
+    const stacked = previous !== undefined && lastContent(previous)?.pos === "ADJ" && lastContent(item)?.pos !== "ADJ";
+    if (stacked) joined[joined.length - 1] = [...previous, ...item];
+    else joined.push(item);
+    return joined;
+  }, []);
+
+/**
+ * 節を並べるなら、どの項目も節。Additionally, others can learn, and the mistake is rarer. の
+ * Additionally は項目ではなく、and の前の読点は節をつなぐ読点。名詞の並びは最初の項目に前置き
+ * （We shipped the parser）を抱えるので、この確かめは節の並びだけにする。
+ * and の後ろだけが節なのは主語の並び（The parser, the renderer and the exporter shipped.）なので外さない。
+ */
+const clausesAgree = (items: readonly Token[][], after: readonly Token[]): boolean => {
+  const last = items.at(-1);
+  if (last === undefined || !isClause(last)) return true;
+  return isClause(after) && items.every(isClause);
+};
+
+/**
+ * 動詞で始まる項目を並べるなら、どの項目にも動詞がある。The scope, in contrast, is larger, and covers ... の
+ * The scope は項目ではなく、後ろの述語の主語。
+ */
+const hasVerb = (item: readonly Token[]): boolean => item.some((token) => VERBAL.has(token.pos));
+
+const predicatesAgree = (items: readonly Token[][], shape: string): boolean => !VERBAL.has(shape) || items.every(hasVerb);
+
+/** -ing 形（VerbForm=Ger）と過去分詞（Part）。filling the gaps と sentenced to prison は並べても並列にならない。 */
+const VERB_FORMS = new Set(["Ger", "Part"]);
+
+const verbFormOf = (token: Token): string | undefined => {
+  const form = token.features?.["VerbForm"];
+  return form !== undefined && VERB_FORMS.has(form) ? form : undefined;
+};
+
+/** 項目の頭の分詞とその形。副詞は飛ばす（originally written）。引用符の中の語（‘modelling’）は語の例なので分詞と読まない。 */
+const participleOpening = (item: readonly Token[], words: ReadonlySet<string>): { readonly at: number; readonly form: string } | undefined => {
+  const at = item.findIndex((token) => token.pos !== "PUNCT" && token.pos !== "ADV");
+  const opening = item[at];
+  if (opening === undefined) return undefined;
+  const form = words.has(opening.surface.toLowerCase()) ? "Ger" : verbFormOf(opening);
+  return form === undefined ? undefined : { at, form };
+};
+
+const hasParticiple = (item: readonly Token[], form: string): boolean => item.some((token) => verbFormOf(token) === form);
+
+/**
+ * 最初より後ろの項目が分詞で始まるとき。最初の項目にも同じ形の分詞があれば分詞の並び
+ * （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）。
+ */
+/** 解析器は過去形と過去分詞（fixed）を見分けられない。動詞のある項目のあとの「過去分詞」の並びは、述語の並びと読む。 */
+const pastPredicates = (first: readonly Token[], form: string, after: readonly Token[], words: ReadonlySet<string>): boolean =>
+  form === "Part" && participleOpening(after, words)?.form === "Part" && hasVerb(first);
+
+const fromParticiplePhrase = (items: readonly Token[][], after: readonly Token[], words: ReadonlySet<string>): readonly Token[][] => {
+  const at = items.findIndex((item, index) => index > 0 && participleOpening(item, words) !== undefined);
+  const phrase = items[at];
+  const first = items[0];
+  const opening = phrase === undefined ? undefined : participleOpening(phrase, words);
+  if (first === undefined || phrase === undefined || opening === undefined) return items;
+  const rest = items.slice(at + 1);
+  const predicates = rest.some((item) => VERBAL.has(shapeOf(item) ?? "")) || pastPredicates(first, opening.form, after, words);
+  if (hasParticiple(first, opening.form) || predicates) return items;
+  const inPhrase = withoutLead([phrase.slice(opening.at + 1), ...rest].filter((item) => item.some(isContent)));
+  return new Set(inPhrase.map(shapeOf)).size > 1 ? rest : inPhrase;
+};
+
+/** 大文字小文字も比べる。頭文字の E.G. Evans / I.E. Evans は e.g. / i.e. ではない。文頭の句の前には項目が無いので、大文字で始まる句は要らない。 */
+const sameSurfaces = (tokens: readonly Token[], words: readonly Token[]): boolean =>
+  tokens.length === words.length && words.every((word, index) => tokens[index]?.surface === word.surface);
+
+/** 項目の中で、and / or と同じ深さにある最後の例の句（such as / e.g.）の直後の位置。無ければ -1。 */
+const exampleEnd = (clause: Clause, level: number, item: readonly Token[]): number =>
+  item.reduce((end, token, at) => {
+    const words = clause.words.example.find(({ tokens = [] }) => tokens.length > 0 && sameSurfaces(item.slice(at, at + tokens.length), tokens))?.tokens ?? [];
+    return words.length > 0 && clause.depths[clause.tokens.indexOf(token)] === level ? at + words.length : end;
+  }, -1);
+
+/**
+ * 例の句（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 = (clause: Clause, at: number, items: readonly Token[][]): readonly Token[][] => {
+  const level = clause.depths[at] ?? 0;
+  const phraseAt = items.findLastIndex((item) => exampleEnd(clause, level, item) !== -1);
+  const phrase = items[phraseAt];
+  if (phrase === undefined) return items;
+  const examples = phrase.slice(exampleEnd(clause, level, phrase));
+  if (examples.some((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase()))) return items;
+  const rest = items.slice(phraseAt + 1);
+  const inPhrase = [examples, ...rest].filter((item) => item.some(isContent));
+  return new Set(inPhrase.map(shapeOf)).size > 1 ? items : inPhrase;
+};
+
+const APPOSITIVE_ANCHOR = new Set(["NOUN", "PROPN"]);
+
+/**
+ * 名詞のすぐ後ろの、読点で挟まれた 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 ...）はこの形と見分けられず、判定から外れる。
+ */
+const isAppositive = (clause: Clause, at: number, items: readonly Token[][], after: readonly Token[]): boolean => {
+  const [anchor, head] = items;
+  if (items.length !== 2 || anchor === undefined || head === undefined || commaBefore(clause.tokens, at)) return false;
+  const end = at + 1 + after.length;
+  // 閉じた読点のあとに and / or が続くなら、並びのあとに節をつないでいる（apples, pears and plums, and went home）。
+  const joinsClause = LIST_CONJUNCTION.has(clause.tokens[end + 1]?.surface.toLowerCase() ?? "");
+  const closed = clause.tokens[end]?.surface === "," && clause.depths[end] === clause.depths[at] && !joinsClause;
+  return closed && APPOSITIVE_ANCHOR.has(lastContent(anchor)?.pos ?? "") && !hasVerb(head) && !hasVerb(after);
+};
+
+/** 副詞を飛ばした頭の形。explain and justify と ultimately ensure は同じ動詞の項目。 */
+const leadShape = (item: readonly Token[]): string | undefined => shapeOf(item.filter((token) => token.pos !== "ADV"));
+
+/**
+ * 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 = (clause: Clause, at: number, after: readonly Token[]): boolean => {
+  const next = at + 1 + after.length;
+  if (clause.tokens[next]?.surface !== "," || !LIST_CONJUNCTION.has(clause.tokens[next + 1]?.surface.toLowerCase() ?? "")) return false;
+  const following = itemAfter(clause.tokens, next + 1);
+  const shape = leadShape(following);
+  return shape !== undefined && shape === leadShape(after) && isClause(following) === isClause(after);
+};
+
+const isPluralNounPhrase = (tokens: readonly Token[]): boolean =>
+  tokens.filter(isContent).every((token) => NOUN_PHRASE_TAIL.has(token.pos)) && lastContent(tokens)?.features?.["Number"] === "Plur";
+
+/**
+ * 語のあとが複数形の名詞句なら、語は名詞にかかる語で、2 つはもう揃っている（the renderer in both modes and the exporter）。
+ * and の後ろも冠詞の無い複数形の名詞句なら、2 つを結ぶ語（both project goals and business goals）。
+ */
+const pairComplete = (member: readonly Token[], after: readonly Token[]): boolean => {
+  const end = after.findIndex((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase()));
+  const partner = end === -1 ? after : after.slice(0, end);
+  return isPluralNounPhrase(member) && !(isPluralNounPhrase(partner) && !partner.some((token) => token.pos === "DET"));
+};
+
+/**
+ * 最後の項目に 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 = (clause: Clause, at: number, items: readonly Token[][], after: readonly Token[]): boolean => {
+  const last = items.at(-1) ?? [];
+  const conjunction = clause.tokens[at]?.surface.toLowerCase() ?? "";
+  const level = clause.depths[at] ?? 0;
+  const opener = last.findLastIndex(
+    (token) => clause.words.pair.has(`${token.surface.toLowerCase()} ${conjunction}`) && clause.depths[clause.tokens.indexOf(token)] === level,
+  );
+  const member = last.slice(opener + 1);
+  if (opener === -1 || commaBefore(clause.tokens, at) || pairComplete(member, after)) return false;
+  return !member.some((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase()));
+};
+
+/** 名詞にかかる語。解析器は分詞を過去形とも読む（registered or certified mail の certified）ので、動詞も数える。 */
+const MODIFIER = new Set(["ADJ", "VERB"]);
+
+const isModifier = (token: Token | undefined): boolean => token?.pos === "ADJ" || (token !== undefined && isParticiple(token));
+
+const NOUN_PHRASE_TAIL = new Set(["ADJ", "NOUN", "PROPN"]);
+
+/** 修飾語と名詞だけの句（certified mail / artificial flavor）。冠詞や目的語を連れた動詞（adopt their resources）は違う。 */
+const isModifiedNoun = (item: readonly Token[]): boolean => {
+  const [head, ...tail] = item.filter((token) => token.pos !== "PUNCT" && token.pos !== "X");
+  return (
+    MODIFIER.has(head?.pos ?? "") && tail.length > 0 && tail.every((token) => NOUN_PHRASE_TAIL.has(token.pos)) && APPOSITIVE_ANCHOR.has(tail.at(-1)?.pos ?? "")
+  );
+};
+
+/**
+ * 修飾語 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 = (clause: Clause, at: number, items: readonly Token[][], after: readonly Token[]): boolean => {
+  const [previous, last] = items.slice(-2);
+  const lone = (last ?? []).filter(isContent);
+  if (commaBefore(clause.tokens, at) || previous === undefined || lone.length !== 1) return false;
+  return isModifier(lone[0]) && !isModifier(lastContent(previous)) && isModifiedNoun(after);
+};
+
+/** 頭の語のあとに前置詞の句を連れた項目（updates on the Google Doc）。 */
+const hasPrepositionalTail = (item: readonly Token[]): boolean => {
+  const head = item.findIndex(isContent);
+  return item.some((token, index) => index > head && token.pos === "ADP");
+};
+
+/**
+ * and / or の後ろの最初の名詞が、最後の項目の前置詞の目的語と同じ品詞で、どの項目の頭とも違う（chat in Slack or Google Hangouts /
+ * Teams (beta): 固有名詞どうし）。頭と同じ品詞なら項目とも読める（petitions for waivers and appeals）ので、並びのまま。
+ */
+const isNoun = (token: Token): boolean => APPOSITIVE_ANCHOR.has(token.pos);
+
+const lastNoun = (item: readonly Token[]): Token | undefined => item.findLast(isNoun);
+
+const likeLastObject = (items: readonly Token[][], after: readonly Token[]): boolean => {
+  const kind = after.find(isNoun)?.pos;
+  return kind !== undefined && lastNoun(items.at(-1) ?? [])?.pos === kind && items.every((item) => item.find(isContent)?.pos !== kind);
+};
+
+/**
+ * どの項目も前置詞の句を連れ、and / or の後ろだけが連れておらず、その目的語に似ていれば、and / or は最後の項目の前置詞の目的語を結ぶ
+ * （updates on the Google Doc, chat in Slack or Google Hangouts は 2 つ）。and / or の前に読点があれば、項目の区切りなので並び。
+ */
+const joinsObjects = (clause: Clause, at: number, items: readonly Token[][], after: readonly Token[]): boolean =>
+  !commaBefore(clause.tokens, at) &&
+  items.every(hasPrepositionalTail) &&
+  !after.some((token) => token.pos === "ADP") &&
+  !hasVerb(after) &&
+  likeLastObject(items, after);
+
+/** and / or が並びの最後の継ぎ目ではなく、最後の項目の中にある。 */
+const insideLastItem = (clause: Clause, at: number, items: readonly Token[][], after: readonly Token[]): boolean =>
+  pairsInLastItem(clause, at, items, after) || sharesNoun(clause, at, items, after) || joinsObjects(clause, at, items, after);
+
+/**
+ * 読点で区切った項目が 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 = (clause: Clause, at: number): boolean | undefined => {
+  const after = itemAfter(clause.tokens, at);
+  const listed = fromExample(clause, at, afterClosedList(withoutLead(joinAdjectives(itemsBefore(clause, at)))));
+  const items = fromParticiplePhrase(listed, after, clause.words.participle);
+  if (listContinues(clause, at, after) || isAppositive(clause, at, items, after) || insideLastItem(clause, at, items, after)) return undefined;
+  const last = items.at(-1);
+  const shape = last === undefined ? undefined : shapeOf(last);
+  if (items.length < 2 || shape === undefined || shape !== shapeOf(after)) return undefined;
+  if (!clausesAgree(items, after) || !predicatesAgree(items, shape)) return undefined;
+  return commaBefore(clause.tokens, at);
+};
+
+/**
+ * 3 つ以上の並列の最後の and / or の前に読点を打つか。Oxford comma。
+ *
+ * どちらが正しいかは決めない。スタイルガイドで割れる論点に立場を取ると rule ごと無視される。
+ * 見るのは 1 つの文書で揃っているかだけ。spec §12.3。
+ */
+const oxfordIn = (tokens: readonly Token[], words: ListWords): boolean | undefined => {
+  const clause = { tokens, depths: depthsOf(tokens), words };
+  return tokens.reduce<boolean | undefined>(
+    (found, token, at) => found ?? (at > 0 && LIST_CONJUNCTION.has(token.surface.toLowerCase()) ? listAt(clause, at) : undefined),
+    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);
+    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/phrase-match.ts

@@ -1,4 +1,4 @@
-import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
 import { entryIn } from "./lexicon-match.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
@@ -22,21 +22,32 @@ const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
     return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
-/**
- * 語彙表との照合。detector は共通で、語彙だけが言語別に差し替わる。spec §11。
- * これが L2 の全体像で、新しい言語は語彙表を書くだけで動く。
- */
-export const phraseMatch: Detector = (doc, options): Finding[] => {
-  const lexicon = options.lexicon ?? [];
-  if (lexicon.length === 0) return [];
-  const hits = hitsIn(inScope(doc, options.where), lexicon);
-  if (hits.length < options.limit) return [];
-  return hits.map((hit) => ({
+const findingsOf = (hits: readonly Hit[], limit: number): Finding[] =>
+  hits.map((hit) => ({
     rule: "",
     severity: "warning",
     line: 0,
     column: 0,
     quote: hit.sentence.text.trim(),
-    values: { matched: hit.matched, count: hits.length, limit: options.limit, offset: hit.sentence.span.start },
+    values: { matched: hit.matched, count: hits.length, limit, offset: hit.sentence.span.start },
   }));
+
+const phraseHits = (doc: ProseDocument, options: DetectorOptions): Hit[] => {
+  const lexicon = options.lexicon ?? [];
+  return lexicon.length === 0 ? [] : hitsIn(inScope(doc, options.where), lexicon);
+};
+
+/**
+ * 語彙表との照合。detector は共通で、語彙だけが言語別に差し替わる。spec §11。
+ * これが L2 の全体像で、新しい言語は語彙表を書くだけで動く。limit は指摘に要る数で、1 なら 1 つ目から言う。
+ */
+export const phraseMatch: Detector = (doc, options): Finding[] => {
+  const hits = phraseHits(doc, options);
+  return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
+};
+
+/** 回数に上限がある語。limit は許す回数で、それを超えたときだけ言う。message の「N 回まで」と同じ向き。 */
+export const phraseCount: Detector = (doc, options): Finding[] => {
+  const hits = phraseHits(doc, options);
+  return hits.length <= options.limit ? [] : findingsOf(hits, options.limit);
 };

package/src/detectors/repeated-head.ts

@@ -35,10 +35,9 @@ const runsOf = (sentences: readonly Sentence[], unit: LengthUnit, lists: readonl
     // 短すぎる書き出しは「同じ」と言えない。単位ぶん揃って初めて連なりと見る。
     const full = unit === "char" ? head.length === HEAD_CHARS : head.split(" ").length === HEAD_WORDS;
     const joins = last !== undefined && last.head === head && last.container === container && !listBetween(last.members.at(-1), sentence, lists);
-    if (last !== undefined && joins && full) {
-      return [...acc.slice(0, -1), { head, container, members: [...last.members, sentence] }];
-    }
-    return [...acc, { head, container, members: [sentence] }];
+    if (last !== undefined && joins && full) acc[acc.length - 1] = { head, container, members: [...last.members, sentence] };
+    else acc.push({ head, container, members: [sentence] });
+    return acc;
   }, []);
 
 export const repeatedHead: Detector = (doc, options): Finding[] =>