chaffjs 0.16.0 → 0.17.0

package/src/detectors/letter-joined-name.ts

@@ -0,0 +1,15 @@
+/**
+ * 一文字を - で語の前に繋いだ名前（J-STAGE、X-RAY、T-Mobile、e-Gov）。前の一文字が新しい名前を作るので、中の大文字の語は
+ * 略語ではない（J-STAGE は STAGE の説明を待たない）。後ろに一文字を繋いだ語（ITU-T、GOODS-S）は略語の一種で、略語は
+ * 説明を待つまま。部品が二つとも二文字以上（RT-PCR）なら繋いだ略語のまま。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+// 語を空白で区切る文字（é、α、分けて書いた e と ́）や数字が接していれば長い語の一部。仮名や漢字は接していてよい（論文はJ-STAGEで）。
+const SPACED_WORD_CHAR = String.raw`\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}\p{M}\p{N}_&`;
+const LETTER_JOINED_NAME = new RegExp(String.raw`(?<![${SPACED_WORD_CHAR}.-])[A-Za-z]-[A-Za-z]{2,}(?![${SPACED_WORD_CHAR}-]|\.[A-Za-z0-9])`, "gu");
+
+/** 文の中の、一文字を - で語の前に繋いだ名前の範囲。 */
+export const letterJoinedNameSpans = (text: string): Span[] =>
+  [...text.matchAll(LETTER_JOINED_NAME)].map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/detectors/lexicon.ts

@@ -1,4 +1,5 @@
 import { joinWords } from "./word-list.ts";
+import { straightApostrophes } from "../orthography.ts";
 import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { entryIn, entryOpens, entryRanges, type TokenRange } from "./lexicon-match.ts";
@@ -227,9 +228,12 @@ export const aiTell: Detector = (doc, options): Finding[] => {
  */
 const containsWord = (text: string, word: string): boolean => new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "u").test(text);
 
+/** アポストロフィの形（don’t と don't）は短縮形かどうかを変えない。違うのは印刷の形で、文体ではない。 */
+const comparableText = (sentence: Sentence): string => straightApostrophes(sentence.text).toLowerCase();
+
 export const contractionMix: Detector = (doc, options): Finding[] => {
   const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ short: entry.pattern, long: entry.instead_of }]));
-  const body = doc.sentences.map((sentence) => sentence.text.toLowerCase()).join(" ");
+  const body = doc.sentences.map(comparableText).join(" ");
   const used = pairs.filter((pair) => containsWord(body, pair.short.toLowerCase()));
   const spelled = pairs.filter((pair) => containsWord(body, pair.long.toLowerCase()));
   // 片方しか無ければ一貫している。両方あるときだけ、少数派を指摘する。
@@ -239,7 +243,7 @@ export const contractionMix: Detector = (doc, options): Finding[] => {
   if (few.length > options.limit) return [];
   const wanted = few.map((pair) => (minorityIsShort ? pair.short : pair.long).toLowerCase());
   const hits = doc.sentences.flatMap((sentence) => {
-    const text = sentence.text.toLowerCase();
+    const text = comparableText(sentence);
     const matched = wanted.find((word) => containsWord(text, word));
     return matched === undefined ? [] : [{ sentence, matched }];
   });

package/src/detectors/orthography.ts

@@ -1,5 +1,5 @@
 import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
-import { calendarRuns, type CalendarRun, type CalendarUnits } from "../calendar-number.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";
@@ -73,7 +73,7 @@ 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") },
+    calendar: calendarUnitsOf(doc),
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);

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/signals.ts

@@ -1,8 +1,8 @@
 import { proseText } from "../measure.ts";
-import { wordsOf } from "./structure.ts";
+import { dateSpans, wordsOf } from "./structure.ts";
 import { compacted, placeOf } from "./gram-place.ts";
 import { notAcronymSpansOf, type NotAcronymSpans } from "./acronym-context.ts";
-import { expansionAt, type ExpandedAt } from "./acronym-expansion.ts";
+import { expansionAt, termEntryAcronyms, type ExpandedAt } from "./acronym-expansion.ts";
 import { isExplained } from "./acronym-compound.ts";
 import { conjugatedForms } from "./conjugated-form.ts";
 import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts";
@@ -200,14 +200,35 @@ const spansOf = (text: string, notation: NotAcronymSpans): Span[] => [
 
 type AcronymHit = { readonly word: string; readonly hit: Hit };
 
+/**
+ * 言語パッケージが、大文字で書いて強調した普通の語（will NEVER call）と読んだ語。辞書がその語を名前になり得ない品詞でしか
+ * 知らないときだけ、そう読む。品詞を持たない言語パッケージでは何も外れない。
+ */
+const isEmphasised = (sentence: Sentence, offset: number): boolean =>
+  (sentence.tokens ?? []).some((token) => token.span.start === offset && token.features?.["Emph"] === "Yes");
+
 /** チームが並べた名前の中の略語（NTT Docomo の NTT）は、名前の一部であって説明を待つ略語ではない。 */
 const acronymsOf = (doc: ProseDocument, notation: NotAcronymSpans): AcronymHit[] =>
   doc.sentences.flatMap((sentence) => {
     const excluded = [...spansOf(sentence.text, notation), ...nameSpans(sentence.text, doc.names ?? [])];
     return [...sentence.text.matchAll(ACRONYM)]
       .filter((match) => !excluded.some((span) => span.start <= match.index && match.index + match[0].length <= span.end))
-      .map((match) => ({ word: match[0], hit: { sentence, offset: sentence.span.start + match.index } }));
+      .map((match) => ({ word: match[0], hit: { sentence, offset: sentence.span.start + match.index } }))
+      .filter(({ hit }) => !isEmphasised(hit.sentence, hit.offset));
+  });
+
+/** 略語ごとの、最初に現れた所。 */
+const firstHits = (hits: readonly AcronymHit[]): Map<string, Hit> => {
+  const seen = new Map<string, Hit>();
+  hits.forEach(({ word, hit }) => {
+    if (!seen.has(word)) seen.set(word, hit);
   });
+  return seen;
+};
+
+/** 日付の中の月（SEP 01, 2022）は略語ではない。 */
+const outsideDates = (hits: readonly AcronymHit[], dates: readonly Span[]): AcronymHit[] =>
+  hits.filter(({ hit }) => !dates.some((span) => span.start <= hit.offset && hit.offset < span.end));
 
 /**
  * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
@@ -227,6 +248,7 @@ const notationOf = (doc: ProseDocument): NotAcronymSpans =>
     emphasis: patternsOf(doc, "emphasis-word"),
     divisions: patternsOf(doc, "numbered-division"),
     honorifics: patternsOf(doc, "honorific"),
+    titles: patternsOf(doc, "name-title"),
     dateTimeUnits: patternsOf(doc, "date-time-unit"),
   });
 
@@ -241,13 +263,14 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   // HTTP のメソッド名（GET）は略語ではないので、通じる略語と同じく展開を求めない。
   // 並べた名前（JAXA）も、繋いだ略語（JAXA-ISAS）の片割れとして説明済みに数える。
   const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method"), ...(doc.names ?? [])]);
-  const seen = new Map<string, Hit>();
-  acronymsOf(doc, notationOf(doc)).forEach(({ word, hit }) => {
-    if (!seen.has(word)) seen.set(word, hit);
-  });
   const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
-  const explainedAlone = (word: string): boolean => common.has(word) || isExpanded(body, word, expandedAt);
-  const bare = [...seen.entries()].filter(([acronym]) => !isExplained(acronym, explainedAlone));
+  const entries = termEntryAcronyms(doc.source);
+  const explainedAlone = (word: string): boolean => common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt);
+  const hits = acronymsOf(doc, notationOf(doc));
+  const unexplained = new Set([...firstHits(hits).keys()].filter((acronym) => !isExplained(acronym, explainedAlone)));
+  // 日付を読むには文書の木を作る。上限に届かない文書では作らない。
+  if (unexplained.size < options.limit) return [];
+  const bare = [...firstHits(outsideDates(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({
     rule: "undefined-acronym",

package/src/detectors/stacked-hedge.ts

@@ -3,7 +3,7 @@ import { entryRanges, type TokenRange } from "./lexicon-match.ts";
 import { isWithinAny, quotedIn, QUOTATION_MARKS } from "../quoted-span.ts";
 
 /** 重ねたと言うのに要る数。1 つなら慎重さで、2 つ目からは読み手が何を言い切ったのか分からなくなる。 */
-export const STACKED_AT = 2;
+const STACKED_AT = 2;
 
 /**
  * 語彙表 3 つ。hedges は逃げの表現そのもの、frames はそれだけでは逃げていない包む言い方（「という状況です」、may）、
@@ -43,7 +43,10 @@ const CLAUSE_BREAK = new Set(["PUNCT", "CCONJ"]);
 
 /** 語ごとの、文の頭から数えた節の番号。 */
 const clauseOf = (tokens: readonly Token[]): number[] =>
-  tokens.reduce<number[]>((clauses, token) => [...clauses, (clauses.at(-1) ?? 0) + (CLAUSE_BREAK.has(token.pos) ? 1 : 0)], []);
+  tokens.reduce<number[]>((clauses, token) => {
+    clauses.push((clauses.at(-1) ?? 0) + (CLAUSE_BREAK.has(token.pos) ? 1 : 0));
+    return clauses;
+  }, []);
 
 const PREDICATE = new Set(["VERB", "AUX"]);
 
@@ -79,7 +82,7 @@ const stackedClause = (devices: readonly Device[], clauses: readonly number[]):
  * 1 つの文の 1 つの節に、逃げの表現を重ねているか。business-blog-harness-spec §7.2。見せる範囲を文の中の順で返す。重ねていなければ空。
  * 品詞が無ければ語の位置が分からないので何も言わない。
  */
-export const stackedHedgeIn = (sentence: Sentence, words: HedgeWords): Span[] => {
+const stackedHedgeIn = (sentence: Sentence, words: HedgeWords): Span[] => {
   const tokens = sentence.tokens ?? [];
   return stackedClause(devicesIn(sentence, words), clauseOf(tokens))
     .toSorted((left, right) => left.range.start - right.range.start)

package/src/detectors/stray-space.ts

@@ -0,0 +1,40 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { minorityStyle } from "../orthography.ts";
+import { isClosed } from "../sentence-shape.ts";
+import { phraseJoints, type Joint, type JointKind } from "../stray-space.ts";
+
+const KINDS: readonly JointKind[] = ["between-phrases", "inside-phrase"];
+
+type Quoted = Joint & { readonly quote: string };
+
+/**
+ * 空けたほうが少ないときだけ、その空白を指摘する。空けたほうが多い文書（文節ごとに空ける分かち書き）は、
+ * その書き方を選んでいるので何も言わない。詰めた境目を「空け忘れ」とは言わない。どこで空けるかは書き手が決める。
+ */
+const strays = (joints: readonly Quoted[]): readonly Quoted[] => (minorityStyle(joints) === true ? joints.filter((joint) => joint.spaced) : []);
+
+/**
+ * 日本語の語句の途中の空白（「こころさんが 払った」「確認 しました」）。句点で終わる文だけを見る。
+ * 句点の無い行（歌、名札と値、表のような行）の空白は区切りとして書かれている。
+ */
+export const straySpace: Detector = (doc, options): Finding[] => {
+  const joints: Quoted[] = doc.sentences
+    .filter(isClosed)
+    .flatMap((sentence) =>
+      phraseJoints(sentence, doc.source.slice(sentence.span.start, sentence.span.end)).map((joint) => ({ ...joint, quote: sentence.text.trim() })),
+    );
+  return KINDS.flatMap((kind) => {
+    const ofKind = joints.filter((joint) => joint.kind === kind);
+    const odd = strays(ofKind);
+    if (odd.length < options.limit) return [];
+    return odd.map((joint) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: joint.quote,
+      variant: kind,
+      values: { before: joint.before, after: joint.after, count: odd.length, of: ofKind.length, limit: options.limit, offset: joint.offset },
+    }));
+  });
+};

package/src/detectors/structure.ts

@@ -3,6 +3,7 @@ import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section,
 import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { preambleParagraphs } from "../preamble-paragraphs.ts";
+import { isTooLongParagraph } from "../paragraph-length.ts";
 
 /**
  * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
@@ -41,7 +42,13 @@ const uniformity = (doc: ProseDocument, values: readonly number[], span: { start
 /** 1 段落に文を詰めすぎると、読み手はどこで息継ぎしていいか分からなくなる。 */
 export const paragraphLength: Detector = (doc, options): Finding[] =>
   doc.paragraphs
-    .filter((paragraph) => paragraph.sentences.length > options.limit)
+    .filter((paragraph) =>
+      isTooLongParagraph(
+        paragraph.sentences.map((sentence) => lengthOf(sentence, doc.lengthUnit)),
+        options.limit,
+        options.fullSentence,
+      ),
+    )
     .map((paragraph) => ({
       rule: "max-paragraph-length",
       severity: "warning",
@@ -93,7 +100,8 @@ export const ruleOfThree: Detector = (doc, options): Finding[] => {
   ];
 };
 
-const dateSpans = (doc: ProseDocument): Span[] =>
+/** 言語パッケージが日付と読んだ範囲（April 1, 2024、SEP 01, 2022）。木を作るので、要るときだけ呼ぶ。 */
+export const dateSpans = (doc: ProseDocument): Span[] =>
   doc.structure === undefined ? [] : inDocumentOrder(doc.structure).flatMap((node) => (node.kind === "date" ? [node.span] : []));
 
 /** 更新日の刻印（「最終更新日:」「2025年6月20日」）は前置きに数えない。木を作るのは、数えて上限を超えたときだけ。 */