chaffjs 0.12.0 → 0.13.0

package/src/detectors/acronym-expansion.ts

@@ -4,10 +4,11 @@ import { escapeRegExp } from "../orthography.ts";
  * 展開は略語の**すぐ隣**にあるときだけ認める。
  * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
  *
- * 認めるのは 4 つの形。どれも実際によく書かれる。
+ * 認めるのは次の形。どれも実際によく書かれる。
  *   CI（継続的インテグレーション）   略語のあとに括弧
  *   Continuous Integration (CI)      括弧の中が略語
  *   Tax Cuts and Jobs Act [TCJA]     角括弧の中が略語で、直前の語の頭文字と揃う
+ *   Relief Act (RA; P.L. 112-240)    括弧の最初の項目が略語で、直前の語か区切りの後の語の頭文字と揃う
  *   人事部（以下「HR」という。）      括弧の中が定義の語と略語だけ
  * 括弧と略語の間には、引用符（(“MNDA”)、（「MNDA」））と空白だけを許す。
  */
@@ -17,6 +18,10 @@ const CLOSES = new RegExp(String.raw`^${WRAP}[)）]`, "u");
 const OPENED = new RegExp(String.raw`[(（]${WRAP}$`, "u");
 const SQUARE_CLOSES = new RegExp(String.raw`^${WRAP}\]`, "u");
 const SQUARE_OPENED = new RegExp(String.raw`\[${WRAP}$`, "u");
+const ANY_OPENED = new RegExp(String.raw`[(（[]${WRAP}$`, "u");
+/** 括弧の最初の項目のあとの区切りと、括弧が閉じるまでの残り（(ARRA; P.L. 111-5)、（OP、Originator Profile））。 */
+const SEPARATED = new RegExp(String.raw`^${WRAP}[;；,，、](?<rest>[^()（）]*)`, "u");
+const QUOTES = /["“”'‘’「」『』]/gu;
 
 /** 括弧と略語の間の幅。空白は 1 つに畳んであるので、(“ MNDA ”) まで収まる。 */
 const NEAR = 3;
@@ -31,15 +36,37 @@ const MARKER_GAP = String.raw`(?![A-Za-z])[\s、,]*`;
  * 角括弧は引用の印にも使う（[IANA]、[1]）。直前の語のうち大文字で始まる語の頭文字が
  * 略語と揃うときだけ展開と見なす。見る語は略語の文字数の 2 倍まで（and や of を挟むため）。
  */
+const lettersOf = (acronym: string): string => acronym.replaceAll("&", "");
+
+const initialsOf = (words: readonly string[]): string =>
+  words
+    .filter((word) => /^[A-Z]/u.test(word))
+    .map((word) => word.charAt(0))
+    .join("");
+
 const spellsOut = (before: string, acronym: string): boolean => {
-  const letters = acronym.replaceAll("&", "");
+  const letters = lettersOf(acronym);
   const words = before
-    .replace(SQUARE_OPENED, "")
+    .replace(ANY_OPENED, "")
     .trim()
     .split(/\s+/u)
     .slice(-letters.length * 2);
-  const initials = words.filter((word) => /^[A-Z]/u.test(word)).map((word) => word.charAt(0));
-  return initials.join("").endsWith(letters);
+  return initialsOf(words).endsWith(letters);
+};
+
+/**
+ * 括弧の最初の項目が略語で、区切りのあとに注記が続く形（(ARRA; P.L. 111-5)、（OP、Originator Profile））。
+ * 同じ形で列挙も書く（(MR, handbook, etc.)、(EPA, FDIC, GSA)）ので、直前の語か、区切りから括弧が閉じるまでの語の
+ * 頭文字が略語と揃うときだけ展開と見なす。区切りの後ろは閉じた括弧の中だけを見て、頭文字がちょうど略語になることを求める。
+ */
+const isSeparatedAt = (body: string, acronym: string, at: number): boolean => {
+  if (!OPENED.test(body.slice(Math.max(0, at - NEAR), at))) return false;
+  const separated = SEPARATED.exec(body.slice(at + acronym.length, at + acronym.length + DEFINITION_REACH));
+  if (separated === null) return false;
+  const rest = separated.groups?.["rest"] ?? "";
+  const end = at + acronym.length + separated[0].length;
+  const closed = CLOSES.test(body.slice(end, end + NEAR));
+  return spellsOut(body.slice(0, at), acronym) || (closed && initialsOf(rest.replace(QUOTES, " ").trim().split(/\s+/u)) === lettersOf(acronym));
 };
 
 /** 言語パッケージの語彙表から読む、括弧の中で略語の前に書く語（以下、hereinafter）と後ろに書く語（という）。 */
@@ -69,7 +96,8 @@ const isBracketedAt = (body: string, acronym: string, at: number): boolean => {
   const after = body.slice(at + acronym.length, at + acronym.length + NEAR);
   const before = body.slice(Math.max(0, at - NEAR), at);
   if (OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after))) return true;
-  return SQUARE_OPENED.test(before) && SQUARE_CLOSES.test(after) && spellsOut(body.slice(0, at), acronym);
+  if (SQUARE_OPENED.test(before) && SQUARE_CLOSES.test(after) && spellsOut(body.slice(0, at), acronym)) return true;
+  return isSeparatedAt(body, acronym, at);
 };
 
 export type ExpandedAt = (body: string, acronym: string, at: number) => boolean;

package/src/detectors/char-shape.ts

@@ -1,6 +1,7 @@
-import type { Detector, DocumentProfile, Finding, Sentence, Token } from "../plugin.ts";
+import type { Detector, DocumentProfile, Finding, Sentence } from "../plugin.ts";
 import { compacted, placeOf } from "./gram-place.ts";
 import { maskAddresses } from "../address-chain.ts";
+import { isAddressRun } from "./place-run.ts";
 import { proseText } from "../measure.ts";
 
 /**
@@ -9,50 +10,30 @@ import { proseText } from "../measure.ts";
  */
 const KANJI_RUN = /[一-鿿]+/gu;
 
-/** 地名（Geo）と、地名に付く単位（GeoUnit: 都・県・市・区・町）。 */
-const isGeoName = (token: Token | undefined): boolean => token?.features?.["NameType"] === "Geo";
-const isGeo = (token: Token | undefined): boolean => isGeoName(token) || token?.features?.["NameType"] === "GeoUnit";
-const isNumber = (token: Token | undefined): boolean => token?.features?.["NumType"] === "Card";
-
-/**
- * 住所の語: 地名と地名の単位（NameType=Geo / GeoUnit）、数（NumType=Card）、数のすぐ後ろの助数詞（丁目、NounType=Class）。
- * 辞書に無い町名（新橋）は、地名の後ろで数の前に来るときだけ住所の一部とする。
- */
-const isPlacePart = (tokens: readonly Token[], index: number): boolean =>
-  isGeo(tokens[index]) ||
-  isNumber(tokens[index]) ||
-  (isNumber(tokens[index - 1]) && tokens[index]?.features?.["NounType"] === "Class") ||
-  (isGeo(tokens[index - 1]) && isNumber(tokens[index + 1]));
-
-/**
- * 漢字の連なりが住所か（東京都港区新橋二丁目）。形態素解析が地名と読んだ語で始まり、住所の語だけでできている。
- * 住所は決まった形で、ひらがなを挟んで書けない。組織名（日本経済団体連合会）は地名の後ろに普通の語が続くので住所ではない。品詞が無ければ判定しない。
- */
-const isPlaceName = (sentence: Sentence, run: string): boolean => {
+/** 漢字の連なりが住所か（東京都港区新橋二丁目）。形態素解析の地名と数で決める。品詞が無ければ判定しない。 */
+const isPlaceName = (sentence: Sentence, run: string, topUnits: ReadonlySet<string>): boolean => {
   const tokens = sentence.tokens;
   const place = tokens === undefined ? undefined : placeOf(compacted(sentence.text, "word"), run);
   if (tokens === undefined || place === undefined) return false;
   const [start, end] = [sentence.span.start + place.start, sentence.span.start + place.end];
   const covering = tokens.flatMap((token, index) => (token.span.start < end && start < token.span.end ? [index] : []));
-  const first = covering[0];
-  // 地名が単位を挟まずに続けば（東京大阪名古屋福岡）、住所ではなく地名の並び。
-  const listed = covering.some((index) => isGeoName(tokens[index]) && isGeoName(tokens[index + 1]));
-  return first !== undefined && isGeo(tokens[first]) && !listed && covering.every((index) => isPlacePart(tokens, index));
+  return isAddressRun(tokens, covering, topUnits);
 };
 
-const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined): string =>
+const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined, topUnits: ReadonlySet<string>): string =>
   [...maskAddresses(proseText(sentence), profile).matchAll(KANJI_RUN)]
     .map((match) => match[0])
-    .filter((run) => !isPlaceName(sentence, run))
+    .filter((run) => !isPlaceName(sentence, run, topUnits))
     .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
 /**
  * 漢字が続くと、どこで語が切れるのか読み手が探すことになる。
  * 「情報処理推進機構認定試験」は 12 字。ひらがなを 1 つ挟むだけで読める。
  */
-export const kanjiRun: Detector = (doc, options): Finding[] =>
-  doc.sentences
-    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile) }))
+export const kanjiRun: Detector = (doc, options): Finding[] => {
+  const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
+  return doc.sentences
+    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits) }))
     .filter(({ run }) => run.length > options.limit)
     .map(({ sentence, run }) => ({
       rule: "max-kanji-continuous",
@@ -62,6 +43,7 @@ export const kanjiRun: Detector = (doc, options): Finding[] =>
       quote: sentence.text.trim(),
       values: { word: run, count: run.length, limit: options.limit, offset: sentence.span.start },
     }));
+};
 
 const MIDDLE_DOT = /・/gu;
 

package/src/detectors/orthography.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, Sentence } from "../plugin.ts";
-import { latinBoundaries, minorityStyle, occurrencesOutside, type SpacingKind } from "../orthography.ts";
+import { latinBoundaries, minorityStyle, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
+import { digitRunAround, isNumberName } from "../number-name.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -23,12 +24,29 @@ const KINDS: readonly SpacingKind[] = ["letter", "before-digit", "after-digit"];
 
 type Located = { readonly sentence: Sentence; readonly offset: number; readonly kind: SpacingKind; readonly spaced: boolean };
 
+/** 境目の隣の数字の、並びの中の 1 字の位置。数字の後ろなら左の字、数字の前なら（空白を越えた）右の字。 */
+const digitBeside = (boundary: Boundary): number => {
+  if (boundary.kind === "after-digit") return boundary.offset - 1;
+  return boundary.spaced ? boundary.offset + 1 : boundary.offset;
+};
+
+/** 番号・識別子として書かれた数の境目は、空け方の好みではないので数えない（number-name.ts）。 */
+const isCounted = (sentence: Sentence, boundary: Boundary): 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);
+};
+
 /**
  * 日本語と英字・数字のあいだを、空けるか詰めるか。文書の中で混ざっていたら、少ないほうを指摘する。
  * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
  */
 export const latinSpacing: Detector = (doc, options): Finding[] => {
-  const located: Located[] = doc.sentences.flatMap((sentence) => latinBoundaries(sentence.text).map((boundary) => ({ sentence, ...boundary })));
+  const located: Located[] = doc.sentences.flatMap((sentence) =>
+    latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
+      .filter((boundary) => isCounted(sentence, boundary))
+      .map((boundary) => ({ sentence, ...boundary })),
+  );
   return KINDS.flatMap((kind) => {
     const ofKind = located.filter((entry) => entry.kind === kind);
     const minority = minorityStyle(ofKind);

package/src/detectors/place-run.ts

@@ -0,0 +1,63 @@
+import type { Token } from "../plugin.ts";
+
+/** 地名（Geo）と、地名に付く単位（GeoUnit: 都・県・郡・市・区・町・村）。 */
+const isGeoName = (token: Token | undefined): boolean => token?.features?.["NameType"] === "Geo";
+const isGeoUnit = (token: Token | undefined): boolean => token?.features?.["NameType"] === "GeoUnit";
+const isGeo = (token: Token | undefined): boolean => isGeoName(token) || isGeoUnit(token);
+const isNumber = (token: Token | undefined): boolean => token?.features?.["NumType"] === "Card";
+
+/**
+ * 辞書に無い町名は、形態素解析が固有名詞か 1 字ずつに割る（紀美野町は 紀＋美野、南伊勢町は 南＋伊勢、久米島町は固有名詞,一般）。
+ * 2 字以上の普通の語（政策・総務）は地名のかけらにしない。
+ */
+const isNamePiece = (token: Token | undefined): boolean => token !== undefined && (token.pos === "PROPN" || [...token.surface].length === 1);
+
+/** 連なりの語と、閉じても 1 つの地名にならない単位（都道府県。住所の先頭にしか来ない。語彙表 prefecture-unit）。 */
+type Run = { readonly tokens: readonly Token[]; readonly last: number; readonly topUnits: ReadonlySet<string> };
+
+/**
+ * index から地名のかけらだけを読み進めて、連なりの終わりまでに都道府県より下の単位（郡・市・町）で閉じるか。
+ * 閉じれば、そこまでが 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);
+};
+
+/**
+ * 住所の語: 地名と地名の単位（NameType=Geo / GeoUnit）、数（NumType=Card）、数のすぐ後ろの助数詞（丁目、NounType=Class）。
+ * 辞書に無い町名（新橋）は、地名の後ろで数の前に来るときだけ住所の一部とする。
+ * 割られた町名（紀美野町）は、単位の後ろで、地名のかけらだけを挟んで次の単位で閉じるときだけ住所の一部とする。
+ */
+const isPlacePart = (run: Run, index: number): boolean => {
+  const tokens = run.tokens;
+  return (
+    isGeo(tokens[index]) ||
+    isNumber(tokens[index]) ||
+    (isNumber(tokens[index - 1]) && tokens[index]?.features?.["NounType"] === "Class") ||
+    (isGeo(tokens[index - 1]) && isNumber(tokens[index + 1])) ||
+    (isGeo(tokens[index - 1]) && isNamePiece(tokens[index]) && closedByUnit(run, index + 1))
+  );
+};
+
+/**
+ * 地名が単位を挟まずに続けば地名の並び（東京大阪名古屋福岡）。ただし 2 つだけで郡・市・町が閉じれば、割られた 1 つの地名
+ * （北海道虻田郡、富士河口湖町）。3 つ続けば、単位が付いても並び（京都奈良大阪神戸市）。
+ * 名古屋大阪市は北海道札幌市と品詞が同じ形なので、ここでは分けられない。
+ */
+const isListed = (run: Run, index: number): boolean =>
+  isGeoName(run.tokens[index]) && isGeoName(run.tokens[index + 1]) && (isGeoName(run.tokens[index + 2]) || !closedByUnit(run, index + 1));
+
+/**
+ * 漢字の連なりの語（covering: tokens の添字）が住所か（東京都港区新橋二丁目）。地名で始まり、住所の語だけでできている。
+ * 住所は決まった形で、ひらがなを挟んで書けない。組織名（日本経済団体連合会）は地名の後ろに普通の語が続くので住所ではない。
+ * topUnits は、住所の先頭にしか来ない単位（都道府県）。言語の語彙表から渡す。
+ */
+export const isAddressRun = (tokens: readonly Token[], covering: readonly number[], topUnits: ReadonlySet<string>): boolean => {
+  const [first, last] = [covering[0], covering.at(-1)];
+  if (first === undefined || last === undefined) return false;
+  const run: Run = { tokens, last, topUnits };
+  return isGeo(tokens[first]) && !covering.some((index) => isListed(run, index)) && covering.every((index) => isPlacePart(run, index));
+};

package/src/detectors/register.ts

@@ -0,0 +1,83 @@
+import type { Sentence, Span, Token } from "../plugin.ts";
+
+export type Register = "polite" | "plain";
+
+const PREDICATE = new Set(["VERB", "ADJ", "AUX"]);
+
+const isPredicate = (token: Token): boolean => PREDICATE.has(token.pos);
+
+const isDependent = (token: Token | undefined): boolean => token?.features?.["NounType"] === "Dependent";
+
+/** preceding の後ろの述語の連なり: 助動詞の連なりと、その前の語一つ。「おかけしましたこと」なら「し・まし・た」。 */
+const chainAtEnd = (preceding: readonly Token[]): readonly Token[] => {
+  const head = preceding.findLastIndex((token) => token.pos !== "AUX");
+  return preceding.slice(Math.max(head, 0));
+};
+
+/**
+ * 非自立名詞で終わる文末は、手前の述語の連なりまで見る。「予約できること。」「おかけしましたこと。」は手前の述語が調子を持つ。
+ * 要件や規程のである調は「〜こと。」で書く。「以下のとおり。」は手前も述語でないので、調子を持たないまま。
+ */
+const withPreceding = (ending: readonly Token[], preceding: readonly Token[]): readonly Token[] =>
+  isDependent(ending[0]) ? [...chainAtEnd(preceding), ...ending] : ending;
+
+/**
+ * 文末の語の調子。preceding は文末の語より前の語。
+ * 文末に述語（動詞・形容詞・助動詞）が無ければ、ですます調でもである調でもないので undefined。
+ * 「以下の通り。」「円錐形の麦わら帽子。」のような名詞で終わる文を数えると、そのままである調の少数派になっていた。
+ * 書いた形でも原形でも当てる。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
+ */
+export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly string[]): Register | undefined => {
+  const judged = withPreceding(ending, preceding);
+  if (!judged.some(isPredicate)) return undefined;
+  const isPolite = judged.some((token) => polite.includes(token.surface) || (token.lemma !== undefined && polite.includes(token.lemma)));
+  return isPolite ? "polite" : "plain";
+};
+
+const EXCLAIMED = /[！？!?]$/u;
+
+/**
+ * 「！」「？」で切れた文が、間を置かずに助詞で始まる次の文へ続くか。「作っていた！！という人」「導入しませんか？が断られた」は、
+ * 分割器が切っても一つの文で、切れ目の手前は書き手の文末ではない。「。」で切れた文は続きとは見ない。
+ */
+export const continuesInto = (sentence: Sentence, next: Sentence | undefined): boolean =>
+  EXCLAIMED.test(sentence.text) && next !== undefined && next.span.start === sentence.span.end && next.tokens?.[0]?.pos === "ADP";
+
+/** 位置 offset を含む一番外側の箇条書きの始まり。本文なら undefined。入れ子の項目は外側の箇条書きと一緒に見る。 */
+export const outermostList = (offset: number, lists: readonly Span[]): number | undefined =>
+  lists
+    .filter((list) => offset >= list.start && offset < list.end)
+    .reduce<number | undefined>((outer, list) => (outer === undefined || list.start < outer ? list.start : outer), undefined);
+
+/** group: 文が入っている箇条書き（outermostList の値）。本文なら undefined。 */
+export type Judged = { readonly register: Register; readonly group: number | undefined };
+
+/** 混ざった文と、その文が属する本文または箇条書きの中の少数派の数。 */
+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;
+
+/** 少ないほう。同数なら文書全体で少ないほう、それも同数なら丁寧体。 */
+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";
+  return countIn(whole, "polite") <= countIn(whole, "plain") ? "polite" : "plain";
+};
+
+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);
+  const slips = members.filter((entry) => entry.register === minority);
+  // 片方しか無ければ揃っている。少数派が閾値を超えて多ければ、混在ではなく別の文体。
+  if (slips.length === 0 || slips.length > limit) return [];
+  return slips.map((entry) => ({ entry, count: slips.length }));
+};
+
+/**
+ * 調子が混ざった文を、judged の順で。本文は本文どうし、箇条書きは 1 つずつ、その中で揃っているかを見る。
+ * ですます調の本文に常体の箇条書きを置くのはよくある書き方で、箇条書きが丸ごと揃っていれば混在ではない。
+ */
+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));
+  return judged.flatMap((entry) => slips.filter((slip) => slip.entry === entry));
+};

package/src/detectors/sentence-ending.ts

@@ -1,4 +1,5 @@
-import { endingTokens, hasPredicate, isClosed } from "../sentence-shape.ts";
+import { endingTokens, isClosed } from "../sentence-shape.ts";
+import { continuesInto, outermostList, registerOf, slipsOf, type Register } from "./register.ts";
 import type { Detector, Finding, Sentence } from "../plugin.ts";
 
 /**
@@ -6,36 +7,31 @@ import type { Detector, Finding, Sentence } from "../plugin.ts";
  *
  * どちらが正しいかは決めない。決めると、方針の違う書き手にそのまま無視される。
  * 見るのは文書の中での一貫性だけで、少数派のほうを指摘する。spec §12.3 の方針を日本語にも。
+ * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）は文として数えない。
  */
-/**
- * 述語を持たないものは文として数えない。見出しの下の `MaaSサービス` のような
- * 名前だけの行がそのまま「である調」の少数派になり、実文書の誤検知はすべてこれだった。
- */
-const isSentence = (sentence: Sentence): boolean => isClosed(sentence) && hasPredicate(sentence) && endingTokens(sentence).length > 0;
+type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
-/**
- * 文末の語だけを見る。文の途中の引用（「ご覧ください」という表現を使う。）は文末の調子ではない。
- * 書いた形でも原形でも当てる。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
- */
-const isPolite = (sentence: Sentence, polite: readonly string[]): boolean =>
-  endingTokens(sentence).some((token) => polite.includes(token.surface) || (token.lemma !== undefined && polite.includes(token.lemma)));
+const registerOfSentence = (sentence: Sentence, polite: readonly string[]): Register | undefined => {
+  const ending = endingTokens(sentence);
+  const tokens = sentence.tokens ?? [];
+  const head = ending[0] === undefined ? -1 : tokens.indexOf(ending[0]);
+  return registerOf(ending, head > 0 ? tokens.slice(0, head) : [], polite);
+};
 
 export const sentenceEnding: Detector = (doc, options): Finding[] => {
   const polite = (options.lexicon ?? []).map((entry) => entry.pattern);
-  const judged = doc.sentences.filter(isSentence).map((sentence) => ({ sentence, polite: isPolite(sentence, polite) }));
-  const counts = { polite: judged.filter((entry) => entry.polite).length, plain: judged.length - judged.filter((entry) => entry.polite).length };
-  const minorityIsPolite = counts.polite <= counts.plain;
-  const few = minorityIsPolite ? counts.polite : counts.plain;
-  // 片方しか無ければ一貫している。少数派が閾値を超えて多ければ、混在ではなく別の文体。
-  if (few === 0 || few > options.limit) return [];
-  return judged
-    .filter((entry) => entry.polite === minorityIsPolite)
-    .map(({ sentence }) => ({
-      rule: "no-mixed-desumasu",
-      severity: "warning",
-      line: 0,
-      column: 0,
-      quote: sentence.text.trim(),
-      values: { count: few, limit: options.limit, offset: sentence.span.start },
-    }));
+  const lists = doc.lists.map((list) => list.span);
+  const judged = doc.sentences.flatMap((sentence, index): Entry[] => {
+    if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1])) return [];
+    const register = registerOfSentence(sentence, polite);
+    return register === undefined ? [] : [{ sentence, register, group: outermostList(sentence.span.start, lists) }];
+  });
+  return slipsOf(judged, options.limit).map(({ entry: { sentence }, count }) => ({
+    rule: "no-mixed-desumasu",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: sentence.text.trim(),
+    values: { count, limit: options.limit, offset: sentence.span.start },
+  }));
 };

package/src/detectors/signals.ts

@@ -1,7 +1,7 @@
 import { proseText } from "../measure.ts";
 import { wordsOf } from "./structure.ts";
 import { compacted, placeOf } from "./gram-place.ts";
-import { notAcronymSpans } from "./acronym-context.ts";
+import { notAcronymSpansOf, type NotAcronymSpans } from "./acronym-context.ts";
 import { expansionAt, type ExpandedAt } from "./acronym-expansion.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 
@@ -183,18 +183,18 @@ type Span = { readonly start: number; readonly end: number };
 
 const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
 
-const spansOf = (text: string): Span[] => [
+const spansOf = (text: string, notation: NotAcronymSpans): Span[] => [
   ...[...text.matchAll(UNCASED_STRETCH)].filter((match) => SHOUTED_RUN.test(match[0])).map(spanOf),
   ...[...text.matchAll(IDENTIFIER)].filter((match) => /\d/u.test(match[0])).map(spanOf),
   ...[QUOTED_CAPS, REQUIREMENT_WORD, LICENCE].flatMap((pattern) => [...text.matchAll(pattern)].map(spanOf)),
-  ...notAcronymSpans(text),
+  ...notation(text),
 ];
 
 type AcronymHit = { readonly word: string; readonly hit: Hit };
 
-const acronymsOf = (doc: ProseDocument): AcronymHit[] =>
+const acronymsOf = (doc: ProseDocument, notation: NotAcronymSpans): AcronymHit[] =>
   doc.sentences.flatMap((sentence) => {
-    const excluded = spansOf(sentence.text);
+    const excluded = spansOf(sentence.text, notation);
     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 } }));
@@ -209,11 +209,20 @@ const isExpanded = (body: string, acronym: string, expandedAt: ExpandedAt): bool
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
+const notationOf = (doc: ProseDocument): NotAcronymSpans =>
+  notAcronymSpansOf({
+    meridiem: patternsOf(doc, "meridiem"),
+    timeZones: patternsOf(doc, "time-zone"),
+    currencies: patternsOf(doc, "currency-code"),
+    usStates: patternsOf(doc, "us-state-code"),
+    emphasis: patternsOf(doc, "emphasis-word"),
+  });
+
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
   const common = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
   const seen = new Map<string, Hit>();
-  acronymsOf(doc).forEach(({ word, hit }) => {
+  acronymsOf(doc, notationOf(doc)).forEach(({ word, hit }) => {
     if (!common.has(word) && !seen.has(word)) seen.set(word, hit);
   });
   const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: patternsOf(doc, "definition-verb") });

package/src/number-name.ts

@@ -0,0 +1,68 @@
+import type { Span, Token } from "./plugin.ts";
+
+/**
+ * 数量ではなく名前として書かれた数（番号・識別子）。鉤括弧で引いた「3.1 リサーチの原則」の節番号、※1 のような注の番号、
+ * 「〒102-0094 東京都」の郵便番号は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
+ * 空け方を数える材料にしない。
+ *
+ * 形で名前と読むのは三つだけ。0 で始まる組を含むハイフンつなぎの番号、※ や鉤括弧のすぐ後ろの番号、文頭の階層つきの節番号（2.1、3.1.2）。
+ * 文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
+ * そのうえで、すぐ後ろ（空白 1 つまで）の語が数につく語（助数詞・数・助詞・助動詞）なら数量として数え続ける（「3-5 日」「26.7 万行」）。
+ * 品詞が無ければ判断せず、名前とは読まない。
+ */
+
+/** 数と結びついて読まれる語。助数詞は NounType=Class、数は NumType=Card で渡る。 */
+const BOUND_TO_NUMBER = new Set(["ADP", "PART", "AUX", "SCONJ", "CCONJ"]);
+
+/** 番号が立つ位置の直前: 題を包む鉤括弧、注の印。 */
+const LABEL_LEAD = /[「『【※]$/u;
+
+/** 文頭（前に空白と箇条書きの印だけ）。 */
+const LINE_HEAD = /^[\s\-*+・•]*$/u;
+
+/** 階層つきの節番号（2.1、3.1.2）。 */
+const SECTION_NUMBER = /^\d+(?:\.\d+)+$/u;
+
+/**
+ * 0 で始まる組を含む、ハイフンでつないだ番号（〒102-0094、03-3501）。二つの数だけの「3-5」は範囲（3-5 営業日）とも読めるので
+ * 数え続ける。三つ以上つないだもの（073-489-5909）は、orthography.ts が境目を作る前に外している。
+ */
+const isHyphenIdentifier = (digits: string): boolean => {
+  const parts = digits.split("-").filter((part) => part !== "");
+  return parts.length > 1 && parts.some((part) => part.startsWith("0"));
+};
+
+const RUN_CHAR = /[\d.-]/u;
+
+/** at を含む、数字・小数点・ハイフンの並び。at が並びの中に無ければ undefined。 */
+export const digitRunAround = (text: string, at: number): Span | undefined => {
+  if (!RUN_CHAR.test(text[at] ?? "")) return undefined;
+  const startAt = (index: number): number => (index > 0 && RUN_CHAR.test(text[index - 1] ?? "") ? startAt(index - 1) : index);
+  const endAt = (index: number): number => (index < text.length && RUN_CHAR.test(text[index] ?? "") ? endAt(index + 1) : index);
+  return { start: startAt(at), end: endAt(at) };
+};
+
+/** 並びの後ろ（空白 1 つまで）で始まる語。 */
+const wordAfter = (tokens: readonly Token[], text: string, run: Span, base: number): Token | undefined => {
+  const next = text[run.end] === " " ? run.end + 1 : run.end;
+  return tokens.find((token) => token.span.start === base + next);
+};
+
+const isBoundToNumber = (token: Token): boolean =>
+  token.features?.["NounType"] === "Class" || token.features?.["NumType"] === "Card" || BOUND_TO_NUMBER.has(token.pos);
+
+/** ハイフンでつないだ識別子か、番号の立つ位置の番号か、文頭の節番号か。 */
+const isNameShaped = (text: string, run: Span): boolean => {
+  const [before, digits] = [text.slice(0, run.start), text.slice(run.start, run.end)];
+  return isHyphenIdentifier(digits) || LABEL_LEAD.test(before) || (LINE_HEAD.test(before) && SECTION_NUMBER.test(digits));
+};
+
+/**
+ * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。
+ * 後ろの語が読めない（品詞が無い、語の切れ目が合わない）ときは、数量として数え続ける。
+ */
+export const isNumberName = (text: string, run: Span, tokens: readonly Token[] | undefined, base: number): boolean => {
+  if (tokens === undefined || !isNameShaped(text, run)) return false;
+  const next = wordAfter(tokens, text, run, base);
+  return next !== undefined && !isBoundToNumber(next);
+};