chaffjs 0.9.0 → 0.11.0

package/src/detectors/lexicon-match.ts

@@ -0,0 +1,44 @@
+import type { LexiconEntry, Sentence, Token } from "../plugin.ts";
+import { proseText } from "../measure.ts";
+
+/** 活用する品詞。"best" を "good" と同じ語にはしない。 */
+const INFLECTING = new Set(["VERB", "AUX"]);
+
+/**
+ * 語彙表が原形で書いた語（いただく）だけが、活用した形（いただきます・いただいた）に当たる。
+ * 活用した形で書いた語（could・かもしれません）はその形だけ。"could" は "can" と言っていることが違う。
+ */
+const sameWord = (written: Token, entry: Token): boolean => {
+  const surface = entry.surface.toLowerCase();
+  if (written.surface.toLowerCase() === surface) return true;
+  const inflects = INFLECTING.has(written.pos) && INFLECTING.has(entry.pos);
+  return inflects && entry.lemma?.toLowerCase() === surface && written.lemma?.toLowerCase() === surface;
+};
+
+const runsAt = (tokens: readonly Token[], entry: readonly Token[], start: number): boolean =>
+  entry.every((word, offset) => {
+    const written = tokens[start + offset];
+    return written !== undefined && sameWord(written, word);
+  });
+
+/**
+ * 語彙の語が文の中にあるか。品詞が付いていれば語の並びで照らし、活用する語は原形で比べる（「させていただく」が「させていただきました」に当たる）。
+ * 語の途中には当たらない（「また」は「またいで」に当たらない）。品詞が無ければ、空白をまとめた文字列で照らす。
+ */
+export const entryIn = (sentence: Sentence, entry: LexiconEntry): boolean => {
+  const tokens = sentence.tokens;
+  const words = entry.tokens;
+  if (tokens === undefined || words === undefined || words.length === 0) return proseText(sentence).toLowerCase().includes(entry.pattern.toLowerCase());
+  return tokens.some((_token, start) => runsAt(tokens, words, start));
+};
+
+const LEADING_MARK = new Set(["PUNCT", "SYM"]);
+
+/** 語彙の語で文が始まるか。文頭の記号は飛ばす。品詞が無ければ文字列の前方一致。 */
+export const entryOpens = (sentence: Sentence, entry: LexiconEntry): boolean => {
+  const tokens = sentence.tokens;
+  const words = entry.tokens;
+  if (tokens === undefined || words === undefined || words.length === 0) return proseText(sentence).toLowerCase().startsWith(entry.pattern.toLowerCase());
+  const first = tokens.findIndex((token) => !LEADING_MARK.has(token.pos));
+  return runsAt(tokens, words, first);
+};

package/src/detectors/lexicon.ts

@@ -1,6 +1,7 @@
-import { proseText } from "../measure.ts";
+import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import { entryIn, entryOpens } from "./lexicon-match.ts";
 
 const PER = 1000;
 
@@ -9,11 +10,8 @@ const FLOOR = { word: 200, char: 500 };
 
 type Hit = { readonly sentence: Sentence; readonly matched: string };
 
-const hitsFor = (doc: ProseDocument, patterns: readonly string[]): Hit[] =>
-  doc.sentences.flatMap((sentence) => {
-    const text = sentence.text.toLowerCase();
-    return patterns.filter((pattern) => text.includes(pattern.toLowerCase())).map((matched) => ({ sentence, matched }));
-  });
+const hitsFor = (doc: ProseDocument, lexicon: Lexicon): Hit[] =>
+  doc.sentences.flatMap((sentence) => lexicon.filter((entry) => entryIn(sentence, entry)).map((entry) => ({ sentence, matched: entry.pattern })));
 
 /**
  * 単位長あたりの出現率。件数で数えると長い文書ほど当たる（bold-density と同じ）。
@@ -22,8 +20,7 @@ const hitsFor = (doc: ProseDocument, patterns: readonly string[]): Hit[] =>
 const densityRule =
   (rule: string): Detector =>
   (doc, options): Finding[] => {
-    const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
-    const hits = hitsFor(doc, patterns);
+    const hits = hitsFor(doc, options.lexicon ?? []);
     const length = wordsOf(doc);
     const rate = length === 0 ? 0 : Math.round((hits.length / length) * PER);
     const first = hits[0];
@@ -48,8 +45,7 @@ export const cushionDensity = densityRule("cushion-phrase-density");
 const QUALIFIER = /\d|より|に比べ|のうち|among|than|compared|based on|according/iu;
 
 export const unqualifiedSuperlative: Detector = (doc, options): Finding[] => {
-  const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
-  const bare = hitsFor(doc, patterns).filter((hit) => !QUALIFIER.test(hit.sentence.text));
+  const bare = hitsFor(doc, options.lexicon ?? []).filter((hit) => !QUALIFIER.test(hit.sentence.text));
   if (bare.length < options.limit) return [];
   return bare.map((hit) => ({
     rule: "unqualified-superlative",
@@ -61,10 +57,10 @@ export const unqualifiedSuperlative: Detector = (doc, options): Finding[] => {
   }));
 };
 
-const openerOf = (doc: ProseDocument, patterns: readonly string[]): (string | undefined)[] =>
+const openerOf = (doc: ProseDocument, lexicon: Lexicon): (string | undefined)[] =>
   doc.paragraphs.map((paragraph) => {
-    const head = paragraph.sentences[0]?.text.trim().toLowerCase() ?? "";
-    return patterns.find((pattern) => head.startsWith(pattern.toLowerCase()));
+    const head = paragraph.sentences[0];
+    return head === undefined ? undefined : lexicon.find((entry) => entryOpens(head, entry))?.pattern;
   });
 
 /**
@@ -72,8 +68,7 @@ const openerOf = (doc: ProseDocument, patterns: readonly string[]): (string | un
  * 前の段落の付け足しに見えて、話がどこへ向かっているのか分からなくなる。
  */
 export const repeatedConjunction: Detector = (doc, options): Finding[] => {
-  const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
-  const openers = openerOf(doc, patterns);
+  const openers = openerOf(doc, options.lexicon ?? []);
   const runs = openers.reduce<{ runs: number[][]; current: number[] }>(
     (acc, opener, index) => {
       if (opener === undefined) return { runs: [...acc.runs, acc.current], current: [] };
@@ -105,11 +100,10 @@ export const repeatedConjunction: Detector = (doc, options): Finding[] => {
  * 単独で断じない。§20.2 の複合シグナルの入口で、これだけで「AI が書いた」とは言わない。
  */
 export const aiTell: Detector = (doc, options): Finding[] => {
-  const weights = new Map((options.lexicon ?? []).map((entry) => [entry.pattern.toLowerCase(), entry.weight ?? 1]));
-  const body = doc.sentences.map(proseText).join(" ").toLowerCase();
-  const found = [...weights.entries()].filter(([pattern]) => body.includes(pattern));
-  const score = Math.round(found.reduce((sum, [, weight]) => sum + weight, 0) * 10);
-  const first = doc.sentences.find((sentence) => found.some(([pattern]) => sentence.text.toLowerCase().includes(pattern)));
+  const entries = [...new Map((options.lexicon ?? []).map((entry) => [entry.pattern.toLowerCase(), entry])).values()];
+  const found = entries.filter((entry) => doc.sentences.some((sentence) => entryIn(sentence, entry)));
+  const score = Math.round(found.reduce((sum, entry) => sum + (entry.weight ?? 1), 0) * 10);
+  const first = doc.sentences.find((sentence) => found.some((entry) => entryIn(sentence, entry)));
   if (first === undefined || score <= options.limit) return [];
   return [
     {
@@ -118,7 +112,16 @@ export const aiTell: Detector = (doc, options): Finding[] => {
       line: 0,
       column: 0,
       quote: first.text.trim(),
-      values: { word: found.map(([pattern]) => pattern).join("、"), count: found.length, density: score, limit: options.limit, offset: first.span.start },
+      values: {
+        word: joinWords(
+          found.map((entry) => entry.pattern.toLowerCase()),
+          doc.language,
+        ),
+        count: found.length,
+        density: score,
+        limit: options.limit,
+        offset: first.span.start,
+      },
     },
   ];
 };

package/src/detectors/phrase-match.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import { entryIn } from "./lexicon-match.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
 const OPENING_SENTENCES = 4;
@@ -15,10 +16,10 @@ const inScope = (doc: ProseDocument, where: string | undefined): readonly Senten
 
 type Hit = { readonly sentence: Sentence; readonly matched: string };
 
-const hitsIn = (sentences: readonly Sentence[], patterns: readonly string[]): Hit[] =>
+const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
   sentences.flatMap((sentence) => {
-    const matched = patterns.find((pattern) => sentence.text.toLowerCase().includes(pattern.toLowerCase()));
-    return matched === undefined ? [] : [{ sentence, matched }];
+    const matched = lexicon.find((entry) => entryIn(sentence, entry));
+    return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
 /**
@@ -26,9 +27,9 @@ const hitsIn = (sentences: readonly Sentence[], patterns: readonly string[]): Hi
  * これが L2 の全体像で、新しい言語は語彙表を書くだけで動く。
  */
 export const phraseMatch: Detector = (doc, options): Finding[] => {
-  const patterns = (options.lexicon ?? []).map((entry) => entry.pattern);
-  if (patterns.length === 0) return [];
-  const hits = hitsIn(inScope(doc, options.where), patterns);
+  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) => ({
     rule: "",

package/src/detectors/repeated-head.ts

@@ -1,4 +1,4 @@
-import type { Detector, Finding, LengthUnit, Sentence } from "../plugin.ts";
+import type { Detector, Finding, LengthUnit, Sentence, Span } from "../plugin.ts";
 
 const HEAD_CHARS = 6;
 const HEAD_WORDS = 3;
@@ -13,22 +13,36 @@ const headOf = (sentence: Sentence, unit: LengthUnit): string => {
   return text.split(/\s+/u).slice(0, HEAD_WORDS).join(" ");
 };
 
-type Run = { readonly head: string; readonly members: readonly Sentence[] };
+/** 文の入れ物。文の始まりを含む、いちばん内側の箇条書きの項目の始まり。地の文なら -1。 */
+const containerOf = (sentence: Sentence, lists: readonly Span[]): number =>
+  lists.filter((item) => item.start <= sentence.span.start && sentence.span.start < item.end).reduce((innermost, item) => Math.max(innermost, item.start), -1);
 
-const runsOf = (sentences: readonly Sentence[], unit: LengthUnit): Run[] =>
+type Run = { readonly head: string; readonly container: number; readonly members: readonly Sentence[] };
+
+/** 前の文と今の文のあいだで、箇条書きの項目が始まっているか。文を持たない項目（画像だけの - ![図](a.png)）も連なりを切る。 */
+const listBetween = (previous: Sentence | undefined, sentence: Sentence, lists: readonly Span[]): boolean =>
+  previous !== undefined && lists.some((item) => item.start >= previous.span.end && item.start < sentence.span.start);
+
+/**
+ * 連なりは同じ入れ物の中でだけ続く。箇条書きの項目どうしは同じ形で並べるのが書き方そのもの（「1. SRE に関する…」「2. SRE に関する…」）で、
+ * 項目をまたぐと切る。一つの項目の中の段落や、地の文の中では、これまでどおり数える。箇条書きの前後の地の文も、箇条書きで切れる。
+ */
+const runsOf = (sentences: readonly Sentence[], unit: LengthUnit, lists: readonly Span[]): Run[] =>
   sentences.reduce<Run[]>((acc, sentence) => {
     const head = headOf(sentence, unit);
+    const container = containerOf(sentence, lists);
     const last = acc.at(-1);
     // 短すぎる書き出しは「同じ」と言えない。単位ぶん揃って初めて連なりと見る。
     const full = unit === "char" ? head.length === HEAD_CHARS : head.split(" ").length === HEAD_WORDS;
-    if (last !== undefined && last.head === head && full) {
-      return [...acc.slice(0, -1), { head, members: [...last.members, sentence] }];
+    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, members: [sentence] }];
+    return [...acc, { head, container, members: [sentence] }];
   }, []);
 
 export const repeatedHead: Detector = (doc, options): Finding[] =>
-  runsOf(doc.sentences, doc.lengthUnit)
+  runsOf(doc.sentences, doc.lengthUnit, doc.listSpans)
     .filter((run) => run.members.length > options.limit)
     .map((run) => ({
       rule: "repeated-sentence-head",

package/src/detectors/sentence-ending.ts

@@ -1,4 +1,4 @@
-import { hasPredicate, isClosed } from "../sentence-shape.ts";
+import { endingTokens, hasPredicate, isClosed } from "../sentence-shape.ts";
 import type { Detector, Finding, Sentence } from "../plugin.ts";
 
 /**
@@ -11,10 +11,14 @@ import type { Detector, Finding, Sentence } from "../plugin.ts";
  * 述語を持たないものは文として数えない。見出しの下の `MaaSサービス` のような
  * 名前だけの行がそのまま「である調」の少数派になり、実文書の誤検知はすべてこれだった。
  */
-const isSentence = (sentence: Sentence): boolean => isClosed(sentence) && hasPredicate(sentence);
+const isSentence = (sentence: Sentence): boolean => isClosed(sentence) && hasPredicate(sentence) && endingTokens(sentence).length > 0;
 
+/**
+ * 文末の語だけを見る。文の途中の引用（「ご覧ください」という表現を使う。）は文末の調子ではない。
+ * 書いた形でも原形でも当てる。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
+ */
 const isPolite = (sentence: Sentence, polite: readonly string[]): boolean =>
-  (sentence.tokens ?? []).some((token) => polite.includes(token.lemma ?? token.surface));
+  endingTokens(sentence).some((token) => polite.includes(token.surface) || (token.lemma !== undefined && polite.includes(token.lemma)));
 
 export const sentenceEnding: Detector = (doc, options): Finding[] => {
   const polite = (options.lexicon ?? []).map((entry) => entry.pattern);

package/src/detectors/signals.ts

@@ -1,6 +1,7 @@
 import { proseText } from "../measure.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import { compacted, placeOf } from "./gram-place.ts";
+import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 
 const PER = 1000;
 
@@ -91,13 +92,44 @@ const gramsOf = (doc: ProseDocument): Map<string, number> => {
   return counts;
 };
 
+/** 数えたときと同じ形の文。char 単位では空白を詰めてから数えている。 */
+const gramText = (sentence: Sentence, unit: ProseDocument["lengthUnit"]): string => compacted(sentence.text, unit).text;
+
+/** 動詞と助動詞。言い回し（ることができます、it is important to）にはこれが入り、主題の名前（state and local tax）には入らない。 */
+const PREDICATE_POS = new Set(["VERB", "AUX"]);
+
+const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
+
+/**
+ * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
+ * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
+ */
+const modifiesNoun = (tokens: readonly Token[], index: number, unit: ProseDocument["lengthUnit"]): boolean =>
+  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
+
+/**
+ * 語句が文の中で占める範囲に、動詞か助動詞があるか。範囲で見る。文字で探すと、同じ文の別の所の動詞「use」が、語句の中の名詞「use」に当たる。
+ * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
+ */
+const hasPredicate = (gram: string, sentence: Sentence, unit: ProseDocument["lengthUnit"]): boolean => {
+  if (sentence.tokens === undefined) return true;
+  const place = placeOf(compacted(sentence.text, unit), gram);
+  if (place === undefined) return true;
+  const [start, end] = [sentence.span.start + place.start, sentence.span.start + place.end];
+  const tokens = sentence.tokens;
+  return tokens.some((token, index) => PREDICATE_POS.has(token.pos) && token.span.start < end && start < token.span.end && !modifiesNoun(tokens, index, unit));
+};
+
 export const ngramRepetition: Detector = (doc, options): Finding[] => {
   if (wordsOf(doc) < FLOOR[doc.lengthUnit]) return [];
+  const sentenceWith = (gram: string): Sentence | undefined => doc.sentences.find((sentence) => gramText(sentence, doc.lengthUnit).includes(gram));
   const worst = [...gramsOf(doc).entries()]
-    .filter(([gram]) => isPhrasing(gram, doc.lengthUnit))
-    .reduce<{ gram: string; count: number }>((best, [gram, count]) => (count > best.count ? { gram, count } : best), { gram: "", count: 0 });
-  if (worst.count <= options.limit) return [];
-  const at = doc.sentences.find((sentence) => sentence.text.includes(worst.gram));
+    .filter(([gram, count]) => count > options.limit && isPhrasing(gram, doc.lengthUnit))
+    .sort(([, left], [, right]) => right - left)
+    .map(([gram, count]) => ({ gram, count, at: sentenceWith(gram) }))
+    .find(({ gram, at }) => at === undefined || hasPredicate(gram, at, doc.lengthUnit));
+  if (worst === undefined) return [];
+  const at = worst.at;
   return [
     {
       rule: "ngram-repetition",
@@ -113,8 +145,57 @@ export const ngramRepetition: Detector = (doc, options): Finding[] => {
 /**
  * 略語が初出で展開されているか。「CI」だけでは、読む人によって指すものが違う。
  * 展開は「略語の直前か直後の括弧」か「括弧の中の略語」で書かれる。
+ *
+ * & で繋いだ大文字は 1 語として読む（ATT&CK、M&IE）。割ると CK や IE が別の略語に見える。
+ */
+const EDGE_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
+const EDGE_AFTER = String.raw`(?![A-Za-z0-9_&])`;
+const ACRONYM = new RegExp(String.raw`${EDGE_BEFORE}(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{2,6})${EDGE_AFTER}`, "gu");
+
+/**
+ * 大文字で書かれていても略語ではないもの。
+ *
+ * 大文字だけの語が 3 つ以上、空白と引用符だけを挟んで続くのは強調（免責の定型文など）。
+ * 強調は読点や括弧をまたいで続くので（THE AUTHOR, THE COMPANY (IF ANY)）、そういう続きを含む
+ * 「大文字以外の文字を含まない一続き」を丸ごと強調と見なす。小文字の語が挟まれば切れるので、
+ * 「SRE, SLO, MTTR」のような略語の並びは残る。引用符に包まれた大文字の句（“AS IS”）も強調。
  */
-const ACRONYM = /\b[A-Z]{2,6}\b/gu;
+const CAPS_WORD = String.raw`[A-Z]+(?:&[A-Z]+)*`;
+const SHOUTED_RUN = new RegExp(String.raw`${EDGE_BEFORE}${CAPS_WORD}(?:[\s"“”'‘’]+${CAPS_WORD}){2,}${EDGE_AFTER}`, "u");
+const UNCASED_STRETCH = /(?:[A-Z]|\P{L})+/gu;
+const QUOTED_CAPS = new RegExp(String.raw`["“'‘]${CAPS_WORD}(?:\s+${CAPS_WORD})+["”'’]`, "gu");
+
+/** RFC 2119 の要件語。定義された普通の語で、1 語でも強調でも現れる。 */
+const REQUIREMENT_WORD = new RegExp(
+  String.raw`${EDGE_BEFORE}(?:(?:MUST|SHALL|SHOULD)(?:\s+NOT)?|NOT\s+RECOMMENDED|REQUIRED|RECOMMENDED|MAY|OPTIONAL)${EDGE_AFTER}`,
+  "gu",
+);
+
+/** - か . で繋がり、数字を含む識別子（AC-2、MS.TEAMS.1.1v1）。大文字の部品は略語ではない。 */
+const IDENTIFIER = /(?<![A-Za-z0-9_&.-])[A-Z0-9][A-Za-z0-9]*(?:[.-][A-Z0-9][A-Za-z0-9]*)+/gu;
+
+/** Creative Commons のライセンス名。CC と BY は 1 つの名前の部品。 */
+const LICENCE = new RegExp(String.raw`${EDGE_BEFORE}CC BY(?:-(?:SA|NC|ND))*${EDGE_AFTER}`, "gu");
+
+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[] => [
+  ...[...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)),
+];
+
+type AcronymHit = { readonly word: string; readonly hit: Hit };
+
+const acronymsOf = (doc: ProseDocument): AcronymHit[] =>
+  doc.sentences.flatMap((sentence) => {
+    const excluded = spansOf(sentence.text);
+    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 } }));
+  });
 
 /** 読み手が説明なしで通じると見なしてよい語。展開すると逆に読みにくい。 */
 const COMMON = new Set([
@@ -146,34 +227,100 @@ const COMMON = new Set([
   "XML",
   "TODO",
   "NOTE",
+  // 通信と符号化。技術文書でなくても説明なしで通じる。
+  "DNS",
+  "IP",
+  "TCP",
+  "UDP",
+  "SSH",
+  "SSL",
+  "TLS",
+  "VPN",
+  "LAN",
+  "UTF",
+  "ASCII",
+  // 機器・形式・単位。
+  "PC",
+  "IT",
+  "SDK",
+  "IDE",
+  "PNG",
+  "JPEG",
+  "GIF",
+  "SVG",
+  "QR",
+  "GPS",
+  "SNS",
+  "TV",
+  "KB",
+  "MB",
+  "GB",
+  "TB",
+  // 役職と国・地域。
+  "CEO",
+  "CTO",
+  "CFO",
+  "US",
+  "UK",
+  "EU",
+  "UN",
+  "DNA",
 ]);
 
 /**
  * 展開は略語の**すぐ隣**にあるときだけ認める。
  * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
  *
- * 認めるのは 2 つの形。どちらも実際によく書かれる。
+ * 認めるのは 3 つの形。どれも実際によく書かれる。
  *   CI（継続的インテグレーション）   略語のあとに括弧
  *   Continuous Integration (CI)      括弧の中が略語
+ *   Tax Cuts and Jobs Act [TCJA]     角括弧の中が略語で、直前の語の頭文字と揃う
+ * 括弧と略語の間には、引用符（(“MNDA”)、（「MNDA」））と空白だけを許す。
+ */
+const WRAP = String.raw`[\s"“”'‘’「」『』]*`;
+const OPENS = new RegExp(String.raw`^${WRAP}[(（]`, "u");
+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");
+
+/** 括弧と略語の間の幅。空白は 1 つに畳んであるので、(“ MNDA ”) まで収まる。 */
+const NEAR = 3;
+
+/**
+ * 角括弧は引用の印にも使う（[IANA]、[1]）。直前の語のうち大文字で始まる語の頭文字が
+ * 略語と揃うときだけ展開と見なす。見る語は略語の文字数の 2 倍まで（and や of を挟むため）。
  */
-const OPENS = /^\s*[(（]/u;
-const CLOSES = /^\s*[)）]/u;
-const OPENED = /[(（]\s*$/u;
+const spellsOut = (before: string, acronym: string): boolean => {
+  const letters = acronym.replaceAll("&", "");
+  const words = before
+    .replace(SQUARE_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);
+};
 
-const isExpanded = (body: string, acronym: string): boolean => {
-  const at = body.indexOf(acronym);
-  if (at === -1) return false;
-  const after = body.slice(at + acronym.length, at + acronym.length + 3);
-  const before = body.slice(Math.max(0, at - 3), at);
-  return OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after));
+const isExpandedAt = (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);
 };
 
+/**
+ * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
+ * 展開がその直後の文にあることが契約書では普通にある。見るのは語として現れた所だけ（CISA の中の CI は見ない）。
+ */
+const isExpanded = (body: string, acronym: string): boolean =>
+  [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}${EDGE_AFTER}`, "gu"))].some((match) => isExpandedAt(body, acronym, match.index));
+
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
   const seen = new Map<string, Hit>();
-  findIn(doc, ACRONYM).forEach((hit) => {
-    const text = /^[A-Z]{2,6}/u.exec(doc.source.slice(hit.offset, hit.offset + 6))?.[0] ?? "";
-    if (text.length > 0 && !COMMON.has(text) && !seen.has(text)) seen.set(text, hit);
+  acronymsOf(doc).forEach(({ word, hit }) => {
+    if (!COMMON.has(word) && !seen.has(word)) seen.set(word, hit);
   });
   const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym));
   if (bare.length < options.limit) return [];
@@ -193,9 +340,29 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
  */
 const CONCRETE = /\d|`|https?:\/\//u;
 
+/**
+ * 見出しのない導入部は、書き出しで呼ぶ。文書の言葉なので、message がどの言語でも混ざらない。
+ * 決まった呼び名（「この節」）を置くと、英語の文書の message に日本語が入る。
+ */
+const OPENING = { word: 4, char: 12 };
+
+const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUnit"]): string => {
+  const text = sentence === undefined ? "" : proseText(sentence);
+  const pieces = unit === "word" ? text.split(" ") : Array.from(text);
+  const joiner = unit === "word" ? " " : "";
+  return pieces.length <= OPENING[unit] ? pieces.join(joiner) : `${pieces.slice(0, OPENING[unit]).join(joiner)}…`;
+};
+
+/**
+ * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
+ * 言い回しの「二人三脚」「一人ひとり」は、辞書が一語として持つので数にならない。品詞が無ければ、数字だけを見る。
+ */
+const hasNumeral = (section: Section): boolean =>
+  section.sentences.some((sentence) => (sentence.tokens ?? []).some((token) => token.features?.["NumType"] === "Card"));
+
 export const concreteEvidence: Detector = (doc, options): Finding[] => {
   const sections = doc.sections.filter((section) => section.sentences.length >= 3);
-  const empty = sections.filter((section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)));
+  const empty = sections.filter((section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeral(section));
   if (empty.length < options.limit) return [];
   return empty.map((section) => ({
     rule: "concrete-evidence-density",
@@ -204,7 +371,7 @@ export const concreteEvidence: Detector = (doc, options): Finding[] => {
     column: 0,
     quote: section.heading.length > 0 ? section.heading : (section.sentences[0]?.text.trim() ?? ""),
     values: {
-      word: section.heading.length > 0 ? section.heading : "この節",
+      word: section.heading.length > 0 ? section.heading : openingOf(section.sentences[0], doc.lengthUnit),
       count: empty.length,
       total: sections.length,
       limit: options.limit,

package/src/detectors/structure-tree.ts

@@ -1,6 +1,9 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { danglingReferences, duplicateDefinitions, type StructureIssue } from "../structure/issues.ts";
+import { danglingReferences, duplicateDefinitions, inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { numberingBreaks } from "../structure/numbering.ts";
+import { weekdayMismatches } from "../structure/weekday.ts";
+import { dateOrderBreaks } from "../structure/date-order.ts";
+import { totalMismatches, type Amount } from "../structure/total.ts";
 
 const QUOTE_LENGTH = 80;
 
@@ -30,3 +33,66 @@ const findingsOf =
 export const danglingReference: Detector = findingsOf("dangling-reference", danglingReferences);
 export const numberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
 export const duplicateDefinition: Detector = findingsOf("duplicate-definition", duplicateDefinitions);
+
+/** 曜日の名前は言語パッケージの語彙表（weekday、日曜日から順）から取る。無ければ番号のまま。 */
+const dayName = (doc: ProseDocument, day: unknown): string => {
+  const index = Number(day);
+  return doc.lexicons["weekday"]?.[index]?.pattern ?? String(index);
+};
+
+export const dateWeekdayMismatch: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : weekdayMismatches(doc.structure).map((issue) => ({
+        rule: "date-weekday-mismatch",
+        severity: "error",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: {
+          date: String(issue.values["date"]),
+          written: dayName(doc, issue.values["written"]),
+          actual: dayName(doc, issue.values["actual"]),
+          offset: issue.offset,
+        },
+      }));
+
+/** 木の日付を、原文の位置と一緒に並べる。 */
+const datedPoints = (tree: NonNullable<ProseDocument["structure"]>): { offset: number; value: string }[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, value: String(node.attrs["value"]) }] : []));
+
+/** 日程の並びに逆らう日付。並びの読み方は原文の行を見るので、木と原文の両方を渡す。 */
+export const dateOrder: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : dateOrderBreaks(doc.source, datedPoints(doc.structure)).map((issue) => ({
+        rule: "date-order",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));
+
+/** 木の数量を、原文の位置と一緒に並べる。 */
+const amountsOf = (tree: NonNullable<ProseDocument["structure"]>): Amount[] =>
+  inDocumentOrder(tree).flatMap((node) =>
+    node.kind === "quantity" ? [{ offset: node.span.start, end: node.span.end, value: Number(node.attrs["value"]), unit: String(node.attrs["unit"]) }] : [],
+  );
+
+/** 合計の行が、上の金額の和と合わない。合計の語は言語パッケージの語彙表（total-label）から取る。 */
+export const totalMismatch: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : totalMismatches(
+        doc.source,
+        amountsOf(doc.structure),
+        (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
+      ).map((issue) => ({
+        rule: "total-mismatch",
+        severity: "error",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));

package/src/detectors/team.ts

@@ -1,4 +1,5 @@
 import { proseText } from "../measure.ts";
+import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
 
@@ -12,7 +13,11 @@ import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
  * 表層でも原形でも当てる。利用者は辞書形で書く（「握る」）が、本文は活用している（「握った」）。
  * 品詞解析があれば原形で当たり、無くても表層で当たる。要求はしない。
  */
-const matches = (sentence: Sentence, word: string): boolean => sentence.text.includes(word) || (sentence.tokens ?? []).some((token) => token.lemma === word);
+const matches = (sentence: Sentence, word: string): boolean => {
+  // 大文字小文字は区別しない。英語の文頭の「Circle back」も「circle back」として当てる。
+  const wanted = word.toLowerCase();
+  return sentence.text.toLowerCase().includes(wanted) || (sentence.tokens ?? []).some((token) => token.lemma?.toLowerCase() === wanted);
+};
 
 export const internalJargon: Detector = (doc, options): Finding[] => {
   const words = (options.lexicon ?? []).map((entry) => entry.pattern);
@@ -53,7 +58,7 @@ export const requiredSections: Detector = (doc, options): Finding[] => {
       line: 0,
       column: 0,
       quote: headings.filter((heading) => heading.length > 0).join(" / "),
-      values: { word: missing.join("、"), count: missing.length, limit: options.limit, offset: 0 },
+      values: { word: joinWords(missing, doc.language), count: missing.length, limit: options.limit, offset: 0 },
     },
   ];
 };

package/src/detectors/word-list.ts

@@ -0,0 +1,2 @@
+/** 語の並べ方は文書の言語に合わせる。日本語は「、」、ほかは ", "。英語の画面に「Risks、Costs」と出さない。 */
+export const joinWords = (words: readonly string[], language: string): string => words.join(language === "ja" ? "、" : ", ");