chaffjs 0.12.0 → 0.14.0

package/src/detectors/acronym-context.ts

@@ -1,34 +1,27 @@
+import { escapeRegExp } from "../orthography.ts";
+import { ROMAN_NUMERAL } from "./roman-numeral.ts";
+
 /**
  * 大文字の語が略語ではなく、決まった書き方の一部として読める所（3:30 PM、1pm ET、USD 1,000、Kansas City, MO 64108）。
  * どれも閉じた集合で、しかも隣の数字があるときだけ認める。PM（project manager）、CT、CA（certificate authority）は
- * 数字の隣でなければ略語のまま数える。
+ * 数字の隣でなければ略語のまま数える。語は言語パッケージの語彙表から読み、書き方の組み立てだけをここに置く。
  */
 
 type Span = { readonly start: number; readonly end: number };
 
-const MERIDIEM = ["AM", "PM"];
-
-/** 業務文書で説明なしに書かれる時間帯。ここに無いもの（ACT など）は略語として数える。 */
-const TIME_ZONE = ["UTC", "GMT", "JST", "ET", "EST", "EDT", "CT", "CST", "CDT", "MT", "MST", "MDT", "PT", "PST", "PDT", "CET", "CEST"];
-
-/** ISO 4217 のうち、業務文書の読み手が説明なしで通じる主要な通貨。CAD は数の隣でも computer-aided design と読める（3 CAD files）ので入れない。 */
-const CURRENCY = ["USD", "EUR", "JPY", "GBP", "CNY", "CHF", "AUD", "KRW", "HKD", "SGD", "INR"];
-
-/** 米国の州・特別区・準州の郵便略号。住所の書き方（, CA 94720）の中でだけ見る。 */
-const US_STATE = [
-  ...["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY"],
-  ...["LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND"],
-  ...["OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY"],
-  ...["DC", "PR", "GU", "VI", "AS", "MP"],
-];
-
-/**
- * 略語として読む字面を持たない英語の機能語。単独の NOT や AND は強調で、展開するものが無い。
- * OR（Oregon、operating room）や IS（International Standard）のように略語でもある語は入れない。
- */
-const PLAIN_WORD = ["NOT", "AND"];
+/** 言語パッケージの語彙表から読む、数字の隣でだけ略語から外す語と、単独で強調として書かれる語。字面どおりに照らす。 */
+export type NotationWords = {
+  readonly meridiem: readonly string[];
+  readonly timeZones: readonly string[];
+  readonly currencies: readonly string[];
+  readonly usStates: readonly string[];
+  readonly emphasis: readonly string[];
+  /** 番号を後ろに書く、文書の区切りの名前（Part、Section、Title）。 */
+  readonly divisions: readonly string[];
+};
 
-const oneOf = (words: readonly string[]): string => `(?:${words.join("|")})`;
+// 空の語彙表は「その書き方が無い」。空の選択肢 (?:) は至る所で空文字に当たるので、何にも当たらない形にする。
+const oneOf = (words: readonly string[]): string => (words.length === 0 ? "(?!)" : `(?:${words.map(escapeRegExp).join("|")})`);
 
 const MINUTES = String.raw`:[0-5]\d`;
 const CLOCK_12 = String.raw`(?<![\d:.])(?:1[0-2]|0?[1-9])(?:${MINUTES})?`;
@@ -38,16 +31,30 @@ const ANY_MERIDIEM = String.raw`[AaPp]\.?[Mm]\.?`;
 /** 桁区切りは 3 桁ずつ揃っているときだけ金額と読む。「item 1, USD」の 1, は金額ではない。 */
 const AMOUNT = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?`;
 
+/**
+ * 区切りの名前のすぐ後ろのローマ数字は番号（Part II、Section VIII、TITLE IV）。名前は語彙表の書き方か、全部大文字。
+ * CD や CI のようにローマ数字としても読める略語は、この位置でなければ略語のまま数える。
+ */
+const divisionOf = (words: readonly string[]): string => oneOf(words.flatMap((word) => [word, word.toUpperCase()]));
+
 // 強調の記号は空白に置き換えてある（**3:30** PM）ので、部品の間の空白は数を問わない。
-const PATTERNS: readonly RegExp[] = [
-  new RegExp(String.raw`${CLOCK_12}\s*${oneOf(MERIDIEM)}`, "gu"),
-  new RegExp(String.raw`(?:${CLOCK_24}|${CLOCK_12}\s*${ANY_MERIDIEM})\s*${oneOf(TIME_ZONE)}`, "gu"),
-  new RegExp(String.raw`${oneOf(CURRENCY)}\s*[$€£¥]?${AMOUNT}`, "gu"),
-  new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(CURRENCY)}`, "gu"),
-  new RegExp(String.raw`,\s+${oneOf(US_STATE)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
-  new RegExp(oneOf(PLAIN_WORD), "gu"),
+const patternsOf = (words: NotationWords): readonly RegExp[] => [
+  new RegExp(String.raw`${CLOCK_12}\s*${oneOf(words.meridiem)}`, "gu"),
+  new RegExp(String.raw`(?:${CLOCK_24}|${CLOCK_12}\s*${ANY_MERIDIEM})\s*${oneOf(words.timeZones)}`, "gu"),
+  new RegExp(String.raw`${oneOf(words.currencies)}\s*[$€£¥]?${AMOUNT}`, "gu"),
+  new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(words.currencies)}`, "gu"),
+  new RegExp(String.raw`,\s+${oneOf(words.usStates)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
+  new RegExp(oneOf(words.emphasis), "gu"),
+  new RegExp(String.raw`(?<![\p{L}\p{N}_])${divisionOf(words.divisions)}\s+${ROMAN_NUMERAL}(?![\p{L}\p{N}_&])`, "gu"),
 ];
 
-/** 文の中で、略語として数えない大文字を含む範囲。略語は範囲にまるごと入るときだけ外れるので、語の境目は見なくてよい（NOTE の中の NOT）。 */
-export const notAcronymSpans = (text: string): Span[] =>
-  PATTERNS.flatMap((pattern) => [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length })));
+export type NotAcronymSpans = (text: string) => Span[];
+
+/**
+ * 文の中で、略語として数えない大文字を含む範囲。語彙表から一度だけ組み立てて、文ごとに呼ぶ。
+ * 略語は範囲にまるごと入るときだけ外れるので、語の境目は見なくてよい（NOTE の中の NOT）。
+ */
+export const notAcronymSpansOf = (words: NotationWords): NotAcronymSpans => {
+  const patterns = patternsOf(words);
+  return (text) => patterns.flatMap((pattern) => [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length })));
+};

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,7 +1,9 @@
-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";
+import { parallelDotCount } from "./middle-dot.ts";
 
 /**
  * 文字の並びを見る検出。漢字の連なりが住所かどうかだけは、形態素解析の地名と数で決める。
@@ -9,50 +11,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,8 +44,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;
+};
 
 /**
  * 中黒で並べると、どこまでが 1 つの項目か分からなくなる。
@@ -71,7 +52,7 @@ const MIDDLE_DOT = /・/gu;
  */
 export const middleDot: Detector = (doc, options): Finding[] =>
   doc.sentences
-    .map((sentence) => ({ sentence, count: [...proseText(sentence).matchAll(MIDDLE_DOT)].length }))
+    .map((sentence) => ({ sentence, count: parallelDotCount(sentence.text) }))
     .filter(({ count }) => count > options.limit)
     .map(({ sentence, count }) => ({
       rule: "no-nakaguro-parallel",

package/src/detectors/conjugated-form.ts

@@ -0,0 +1,40 @@
+import type { Sentence, Token } from "../plugin.ts";
+
+/**
+ * 語彙表が原形で書いた語句（という、と呼ぶ）が、文の中で活用して書かれた形（といいます、と呼びました）。
+ * 語句の最後の動詞を原形（lemma）で照らし、その前の部分は字面で照らす。語句を語に分けて並びで照らさないのは、
+ * 解析器が単独の「という」を 1 つの助詞に、「といいます」を と・いい・ます に分け、「称し」の原形を 称す とするから。
+ * 活用した形は、動詞に続く助動詞（ます、た）まで。品詞が無い文からは何も出ない。
+ */
+
+type Run = { readonly start: number; readonly end: number };
+
+/** 動詞と、そのすぐ後ろに続く助動詞の、文の中の範囲。 */
+const inflectedRun = (sentence: Sentence, tokens: readonly Token[], index: number, verb: Token): Run => {
+  const rest = tokens.slice(index + 1);
+  const stop = rest.findIndex((token) => token.pos !== "AUX");
+  const last = (stop === -1 ? rest : rest.slice(0, stop)).at(-1) ?? verb;
+  return { start: verb.span.start - sentence.span.start, end: last.span.end - sentence.span.start };
+};
+
+const formsAt = (sentence: Sentence, tokens: readonly Token[], index: number, bases: readonly string[]): string[] => {
+  const verb = tokens[index];
+  const lemma = verb?.lemma;
+  if (verb?.pos !== "VERB" || lemma === undefined || lemma === "") return [];
+  const run = inflectedRun(sentence, tokens, index, verb);
+  const before = sentence.text.slice(0, run.start);
+  const written = sentence.text.slice(run.start, run.end);
+  return bases
+    .filter((base) => base.endsWith(lemma))
+    .map((base) => base.slice(0, base.length - lemma.length))
+    .filter((head) => before.endsWith(head))
+    .map((head) => `${head}${written}`);
+};
+
+export const conjugatedForms = (sentences: readonly Sentence[], bases: readonly string[]): string[] => {
+  const forms = sentences.flatMap((sentence) => {
+    const tokens = sentence.tokens ?? [];
+    return tokens.flatMap((_token, index) => formsAt(sentence, tokens, index, bases));
+  });
+  return [...new Set(forms)];
+};

package/src/detectors/enumerated-runs.ts

@@ -0,0 +1,68 @@
+import type { Sentence, Span, StructureNode, Token } from "../plugin.ts";
+
+/** 番号の付いた行。start は行の始まり（字下げの前）、label は言語パッケージが読んだ番号（「（1）」）。 */
+export type NumberedStart = { readonly start: number; readonly label: string };
+
+const labelOf = (node: StructureNode): string => {
+  const label = node.attrs["label"];
+  return typeof label === "string" ? label : "";
+};
+
+/**
+ * 条の外で、番号の付いた行（言語パッケージが項目と読んだ「（1）」など）。
+ * 条の中の番号付きの行は、条の項（条の本文の続き）でもありうるので数えない。
+ */
+export const numberedStarts = (node: StructureNode, inArticle = false): NumberedStart[] => [
+  ...(node.kind === "item" && !inArticle ? [{ start: node.span.start, label: labelOf(node) }] : []),
+  ...node.children.flatMap((child) => numberedStarts(child, inArticle || node.kind === "article")),
+];
+
+const INDENT = /^[ \t\u3000]*/u;
+
+const lineAt = (source: string, start: number): string => {
+  const end = source.indexOf("\n", start);
+  return source.slice(start, end === -1 ? source.length : end);
+};
+
+/** 番号の直後の語。字下げと番号と空白を飛ばした先の、最初の語。 */
+const wordAfter = (numbered: NumberedStart, sentences: readonly Sentence[], source: string): Token | undefined => {
+  const after = numbered.start + (INDENT.exec(lineAt(source, numbered.start))?.[0].length ?? 0) + numbered.label.length;
+  const sentence = sentences.find((candidate) => candidate.span.end > after);
+  return sentence?.tokens?.find((token) => token.span.start >= after && token.surface.trim() !== "");
+};
+
+/**
+ * 並びの項目として番号を振った行の始まり。番号の直後が助詞（「（1）の金額は」「（2）は対象外」）なら、
+ * 番号は項目の印ではなく、項目を指す本文の主語や修飾なので除く。
+ */
+export const enumeratorStarts = (numbered: readonly NumberedStart[], sentences: readonly Sentence[], source: string): number[] =>
+  numbered.filter((line) => wordAfter(line, sentences, source)?.pos !== "ADP").map((line) => line.start);
+
+/** 番号の付いた行の始まりと段落の始まりのあいだが字下げだけなら、段落はその行から始まる。 */
+const opensWithItem = (paragraph: Span, starts: readonly number[], source: string): boolean =>
+  starts.some((start) => start <= paragraph.start && source.slice(start, paragraph.start).trim() === "");
+
+const isBlank = (source: string, from: number, to: number): boolean => source.slice(from, to).trim() === "";
+
+/** 並びと読むのに要る、番号の付いた行の数。一つだけなら、並びではなく番号で始まる本文の段落かもしれない。 */
+const MIN_ITEMS = 2;
+
+/** 番号の行の始まりは字下げの前なので、並びの最初の行の頭から数える。 */
+const itemsIn = (run: Span, starts: readonly number[], source: string): number => {
+  const lineStart = source.lastIndexOf("\n", run.start - 1) + 1;
+  return starts.filter((start) => start >= lineStart && start < run.end).length;
+};
+
+/**
+ * 番号で始まる段落が、空行だけを挟んで続く範囲。番号の付いた行を二つ以上含むものだけ。
+ * 要件や条件を「（1）…であること。」と並べるのは、段落でも箇条書きと同じ書き方で、本文の調子とは別に揃える。
+ */
+export const enumeratedRuns = (paragraphs: readonly Span[], starts: readonly number[], source: string): Span[] => {
+  const enumerated = paragraphs.filter((paragraph) => opensWithItem(paragraph, starts, source));
+  const runs = enumerated.reduce<Span[]>((joined, paragraph) => {
+    const last = joined.at(-1);
+    if (last === undefined || !isBlank(source, last.end, paragraph.start)) return [...joined, paragraph];
+    return [...joined.slice(0, -1), { start: last.start, end: paragraph.end }];
+  }, []);
+  return runs.filter((run) => itemsIn(run, starts, source) >= MIN_ITEMS);
+};

package/src/detectors/middle-dot.ts

@@ -0,0 +1,10 @@
+const MIDDLE_DOT = /・/gu;
+
+/** 文頭か行頭（前に空白だけ）の「・」。前に並べる項目が無いので、箇条書きの印。 */
+const BULLET_DOT = /(^|\n)[^\S\n]*・/gu;
+
+/**
+ * 項目を並べる中黒の数。箇条書きの印の「・」は数えない。
+ * 「・ 水分を補給すること」が何行続いても、どこまでが 1 つの項目かは改行で読める。
+ */
+export const parallelDotCount = (text: string): number => [...text.replace(BULLET_DOT, "$1").matchAll(MIDDLE_DOT)].length;

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, sequenceLabelStarts } from "../number-name.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -23,12 +24,31 @@ 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, sequence: ReadonlySet<number>): 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);
+};
+
 /**
  * 日本語と英字・数字のあいだを、空けるか詰めるか。文書の中で混ざっていたら、少ないほうを指摘する。
  * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
  */
 export const latinSpacing: Detector = (doc, options): Finding[] => {
-  const located: Located[] = doc.sentences.flatMap((sentence) => latinBoundaries(sentence.text).map((boundary) => ({ sentence, ...boundary })));
+  // 覆った文（prose）で探す。コードの中の「1 件」は並びに入れない。
+  const sequence = sequenceLabelStarts(doc.prose ?? doc.source);
+  const located: Located[] = doc.sentences.flatMap((sentence) =>
+    latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
+      .filter((boundary) => isCounted(sentence, boundary, sequence))
+      .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/polite-word.ts

@@ -0,0 +1,14 @@
+import type { LexiconEntry, Token } from "../plugin.ts";
+
+/** 語彙表の語が解析器で一語になったときの、その語。二語以上（「ございます」）は読みで照らさない。 */
+const singleWord = (entry: LexiconEntry): Token | undefined => (entry.tokens?.length === 1 ? entry.tokens[0] : undefined);
+
+/**
+ * 読みと品詞が同じなら、表記が違っても同じ語の同じ形。解析器は「下さい」の原形を「下さる」、「ください」の原形を「くださる」と
+ * 別の字で返すが、読み（クダサイ）と品詞は同じ。品詞も比べるのは、読みだけだと「升（マス）」が「ます」に当たるから。
+ */
+const sameReading = (token: Token, word: Token | undefined): boolean => word?.reading !== undefined && token.reading === word.reading && token.pos === word.pos;
+
+/** 語が丁寧語の語彙表の語か。書いた形か原形が語彙表の語と同じか、語彙表の一語と読みと品詞が同じ。 */
+export const isPoliteWord = (token: Token, entries: readonly LexiconEntry[]): boolean =>
+  entries.some((entry) => token.surface === entry.pattern || token.lemma === entry.pattern || sameReading(token, singleWord(entry)));

package/src/detectors/register.ts

@@ -0,0 +1,87 @@
+import { isPoliteWord } from "./polite-word.ts";
+import type { LexiconEntry, 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。
+ * 「以下の通り。」「円錐形の麦わら帽子。」のような名詞で終わる文を数えると、そのままである調の少数派になっていた。
+ * 書いた形でも原形でも読みでも当てる（polite-word.ts）。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
+ */
+export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly LexiconEntry[]): Register | undefined => {
+  const judged = withPreceding(ending, preceding);
+  if (!judged.some(isPredicate)) return undefined;
+  return judged.some((token) => isPoliteWord(token, polite)) ? "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);
+
+/** 文が入っているまとまりの始まり。一番外側の箇条書き、それが無ければ番号で始まる段落の並び（runs）。本文なら undefined。 */
+export const groupOf = (offset: number, lists: readonly Span[], runs: readonly Span[]): number | undefined =>
+  outermostList(offset, lists) ?? outermostList(offset, runs);
+
+/** group: 文が入っているまとまり（groupOf の値）。本文なら 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/roman-numeral.ts

@@ -0,0 +1,5 @@
+/**
+ * 崩れのない書き方のローマ数字（I〜MMMM）。IIII や VX は数として書かれないので、略語の側に残す。
+ * 各桁が省けるので空文字にも当たる。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})";