chaffjs 0.16.0 → 0.18.0

package/src/detectors/sentence-ending.ts

@@ -12,11 +12,11 @@ import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } f
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
-const registerOfSentence = (sentence: Sentence, polite: readonly LexiconEntry[]): Register | undefined => {
+const registerOfSentence = (sentence: Sentence, polite: readonly LexiconEntry[], neutral: readonly LexiconEntry[]): 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);
+  return registerOf(ending, head > 0 ? tokens.slice(0, head) : [], polite, neutral);
 };
 
 /** 番号で始まる段落の並び。木を組むのは高いので、調子が一つだけの文書（混ざりようがない）では組まない。 */
@@ -30,25 +30,32 @@ const runsOf = (doc: ProseDocument, registers: readonly Register[]): Span[] => {
   );
 };
 
-export const sentenceEnding: Detector = (doc, options): Finding[] => {
-  const polite = options.lexicon ?? [];
+/** 調子を持つ文と、比べ合うまとまり（groupOf）。polite は語彙表 polite-ending。 */
+export const judgedSentences = (doc: ProseDocument, polite: readonly LexiconEntry[]): Entry[] => {
+  const neutral = doc.lexicons["neutral-ending"] ?? [];
   const lists = doc.lists.map((list) => list.span);
   const found = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
     if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1])) return [];
-    const register = registerOfSentence(sentence, polite);
+    const register = registerOfSentence(sentence, polite, neutral);
     return register === undefined ? [] : [{ sentence, register }];
   });
   const runs = runsOf(
     doc,
     found.map((entry) => entry.register),
   );
-  const judged = found.map((entry): Entry => ({ ...entry, group: groupOf(entry.sentence.span.start, lists, runs) }));
-  return slipsOf(judged, options.limit).map(({ entry: { sentence }, count }) => ({
+  return found.map((entry): Entry => ({ ...entry, group: groupOf(entry.sentence.span.start, lists, runs) }));
+};
+
+export const sentenceEnding: Detector = (doc, options): Finding[] => {
+  const judged = judgedSentences(doc, options.lexicon ?? []);
+  // 数えたのは文が属するまとまりの中なので、文言もそのまとまりを名指す（本文の中で / この箇条書きの中で）。
+  return slipsOf(judged, options.limit).map(({ entry: { sentence, group }, count }) => ({
     rule: "no-mixed-desumasu",
     severity: "warning",
     line: 0,
     column: 0,
     quote: sentence.text.trim(),
+    ...(group === undefined ? {} : { variant: "list" }),
     values: { count, limit: options.limit, offset: sentence.span.start },
   }));
 };

package/src/detectors/sentence-length.ts

@@ -1,15 +1,26 @@
 import { lengthOf, proseText } from "../measure.ts";
-import type { Detector, Finding } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, LengthUnit, Sentence } from "../plugin.ts";
+
+type Measure = { readonly size: number; readonly limit: number; readonly variant?: string };
+
+/** 文書と違う言語の文（和文の中の英文）は、その言語の単位と上限で測る。rule がその言語の段を持たなければ文書のもので。 */
+const measureOf = (sentence: Sentence, unit: LengthUnit, options: DetectorOptions): Measure => {
+  const embedded = sentence.embeddedLanguage;
+  const limit = embedded === undefined ? undefined : options.embeddedLimits?.[embedded.id];
+  if (embedded === undefined || limit === undefined) return { size: lengthOf(sentence, unit), limit: options.limit };
+  return { size: lengthOf(sentence, embedded.lengthUnit), limit, variant: `embedded-${embedded.id}` };
+};
 
 export const sentenceLength: Detector = (doc, options): Finding[] =>
   doc.sentences
-    .map((sentence) => ({ sentence, size: lengthOf(sentence, doc.lengthUnit) }))
-    .filter(({ size }) => size > options.limit)
-    .map(({ sentence, size }) => ({
+    .map((sentence) => ({ sentence, measure: measureOf(sentence, doc.lengthUnit, options) }))
+    .filter(({ measure }) => measure.size > measure.limit)
+    .map(({ sentence, measure }) => ({
       rule: "max-sentence-length",
       severity: "warning",
       line: 0,
       column: 0,
       quote: proseText(sentence),
-      values: { count: size, limit: options.limit, offset: sentence.span.start },
+      values: { count: measure.size, limit: measure.limit, offset: sentence.span.start },
+      ...(measure.variant === undefined ? {} : { variant: measure.variant }),
     }));

package/src/detectors/signals.ts

@@ -1,8 +1,10 @@
 import { proseText } from "../measure.ts";
-import { wordsOf } from "./structure.ts";
-import { compacted, placeOf } from "./gram-place.ts";
+import { dateSpans, wordsOf } from "./structure.ts";
+import { compacted, placeAt, type Compacted } from "./gram-place.ts";
+import { charWindows, wordWindows } from "./gram-windows.ts";
+import { furnitureMask, isFurniture } from "./gram-furniture.ts";
 import { notAcronymSpansOf, type NotAcronymSpans } from "./acronym-context.ts";
-import { expansionAt, type ExpandedAt } from "./acronym-expansion.ts";
+import { abbreviates, 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";
@@ -17,7 +19,7 @@ const PER = 1000;
  * これより短い文書では密度が暴れる。1 個で「1000 あたり 100」になる。
  * 単位は言語で違うので、床も分ける。英語の 200 語と日本語の 200 文字では長さが桁で違う。
  */
-const FLOOR = { word: 200, char: 500 };
+export const MIN_DOCUMENT_LENGTH = { word: 200, char: 500 };
 
 const bodyOf = (doc: ProseDocument): string => doc.sentences.map(proseText).join(" ");
 
@@ -41,7 +43,7 @@ export const emojiDensity: Detector = (doc, options): Finding[] => {
   const hits = findIn(doc, EMOJI);
   const first = hits[0];
   const rate = density(doc, hits.length);
-  if (wordsOf(doc) < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+  if (wordsOf(doc) < MIN_DOCUMENT_LENGTH[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
   return [
     {
       rule: "emoji-density",
@@ -55,26 +57,17 @@ export const emojiDensity: Detector = (doc, options): Finding[] => {
 };
 
 /**
- * 同じ言い回しの繰り返し。character n-gram で見るので、語の区切りが要らない。
+ * 同じ言い回しの繰り返し。文字の並びで見るので、adapter の語の区切り（wordSplit）が要らない。英語の窓は空白で語の切れ目にそろえる。
  * spec §10 が n-gram を選んだのはこのためで、新しい言語でそのまま動く。
  */
 /**
  * 窓の幅は単位で分ける。同じ 8 文字でも、日本語では 4〜5 形態素だが英語では 1 語半にしかならない。
- * 実文書（英語 11 本）で 8 文字にしたら、上位は " generat"（generate）のような**語の断片**だった。
+ * 英語の窓は語の切れ目にそろえ、18 文字に届くまで語を足す。文字で切ると " generat" のような語の断片が上位に来る。
+ * 18 は、文字で切っていた頃の 20 文字の窓から前後の空白を除いた長さ（" juxtaposed to said "）。
  */
-const GRAM = { char: 8, word: 20 };
-
-/** 並べた名前にかかる語句は数えない。名前が繰り返されれば、その前後（「the …」）も一緒に繰り返されるのは当たり前。 */
-const countGrams = (text: string, width: number, names: readonly string[]): Map<string, number> => {
-  const counts = new Map<string, number>();
-  const named = nameSpans(text, names);
-  Array.from({ length: Math.max(0, text.length - width + 1) }).forEach((_, index) => {
-    if (touchesAny(named, index, index + width)) return;
-    const gram = text.slice(index, index + width);
-    counts.set(gram, (counts.get(gram) ?? 0) + 1);
-  });
-  return counts;
-};
+const GRAM = { char: 8, word: 18 };
+
+const windowsOf = (text: string, unit: ProseDocument["lengthUnit"]): Span[] => (unit === "char" ? charWindows(text, GRAM.char) : wordWindows(text, GRAM.word));
 
 /**
  * 名前ではなく言い回しだけを数える。実文書で測ったら、上位は
@@ -93,49 +86,80 @@ const CONNECTIVE = { char: /[ぁ-ゖ].*[ぁ-ゖ].*[ぁ-ゖ]/u, word: /\S \S.*\S
 
 const isPhrasing = (gram: string, unit: ProseDocument["lengthUnit"]): boolean => CONNECTIVE[unit].test(gram);
 
-/** 文をまたいで数えない。文の終わりと次の文の始まりが繋がると、固有名詞が言い回しに見える。 */
-const gramsOf = (doc: ProseDocument): Map<string, number> => {
-  const counts = new Map<string, number>();
-  doc.sentences.forEach((sentence) => {
-    const text = doc.lengthUnit === "char" ? proseText(sentence).replace(/\s+/gu, "") : proseText(sentence);
-    const names = doc.lengthUnit === "char" ? (doc.names ?? []).map((name) => name.replace(/\s+/gu, "")) : (doc.names ?? []);
-    countGrams(text, GRAM[doc.lengthUnit], names).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
-  });
-  return counts;
+/** 語句が最初に数えられた所。書かれたままの語句と、文と、文の中の範囲（sentence.text の位置）。 */
+type FirstSeen = { readonly gram: string; readonly sentence: Sentence; readonly place: Span };
+
+type Tally = { readonly counts: Map<string, number>; readonly first: Map<string, FirstSeen> };
+
+/** 詰めた文の index 番目の文字が、リンクの文字か。 */
+const linkedIn = (doc: ProseDocument, sentence: Sentence, source: Compacted): ((index: number) => boolean) => {
+  const links = doc.links.filter((link) => link.start < sentence.span.end && sentence.span.start < link.end);
+  return (index) => {
+    const at = sentence.span.start + (source.offsets[index] ?? -1);
+    return links.some((link) => link.start <= at && at < link.end);
+  };
+};
+
+/** 英語は大文字と小文字を区別せずに数える。文頭の "Proposals submitted via" も文中の "proposals submitted via" も同じ言い回し。 */
+const keyOf = (gram: string, unit: ProseDocument["lengthUnit"]): string => (unit === "word" ? gram.toLowerCase() : gram);
+
+const namesOf = (doc: ProseDocument): readonly string[] =>
+  doc.lengthUnit === "char" ? (doc.names ?? []).map((name) => name.replace(/\s+/gu, "")) : (doc.names ?? []);
+
+/**
+ * 文をまたいで数えない。文の終わりと次の文の始まりが繋がると、固有名詞が言い回しに見える。
+ * 並べた名前にかかる語句も数えない。名前が繰り返されれば、その前後（「the …」）も一緒に繰り返されるのは当たり前。
+ * 一覧の飾り（gram-furniture.ts）も数えない。項目ごとに繰り返すのはひな形で、書き手ではない。
+ */
+const tallySentence = (doc: ProseDocument, sentence: Sentence, tally: Tally): void => {
+  const source = compacted(sentence.text, doc.lengthUnit);
+  const named = nameSpans(source.text, namesOf(doc));
+  const mask = furnitureMask(source.text, linkedIn(doc, sentence, source));
+  windowsOf(source.text, doc.lengthUnit)
+    .filter((window) => !touchesAny(named, window.start, window.end) && !isFurniture(source.text, mask, window))
+    .forEach((window) => {
+      const gram = source.text.slice(window.start, window.end);
+      const key = keyOf(gram, doc.lengthUnit);
+      tally.counts.set(key, (tally.counts.get(key) ?? 0) + 1);
+      const place = placeAt(source, window);
+      if (!tally.first.has(key) && place !== undefined) tally.first.set(key, { gram, sentence, place });
+    });
 };
 
-/** 数えたときと同じ形の文。char 単位では空白を詰めてから数えている。 */
-const gramText = (sentence: Sentence, unit: ProseDocument["lengthUnit"]): string => compacted(sentence.text, unit).text;
+const gramsOf = (doc: ProseDocument): Tally => {
+  const tally: Tally = { counts: new Map(), first: new Map() };
+  doc.sentences.forEach((sentence) => tallySentence(doc, sentence, tally));
+  return tally;
+};
 
 /**
  * 語句が文の中で占める範囲に、述語になる動詞か助動詞があるか（gram-predicate.ts）。
  * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
  */
-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;
-  return hasPredicateIn(sentence.tokens, { start: sentence.span.start + place.start, end: sentence.span.start + place.end }, unit);
+const hasPredicate = (at: FirstSeen | undefined, unit: ProseDocument["lengthUnit"]): boolean => {
+  if (at?.sentence.tokens === undefined) return true;
+  const start = at.sentence.span.start;
+  return hasPredicateIn(at.sentence.tokens, { start: start + at.place.start, end: start + at.place.end }, 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, count]) => count > options.limit && isPhrasing(gram, doc.lengthUnit))
+  if (wordsOf(doc) < MIN_DOCUMENT_LENGTH[doc.lengthUnit]) return [];
+  const tally = gramsOf(doc);
+  const worst = [...tally.counts.entries()]
+    .filter(([key, count]) => count > options.limit && isPhrasing(key, doc.lengthUnit))
     .toSorted(([, left], [, right]) => right - left)
-    .map(([gram, count]) => ({ gram, count, at: sentenceWith(gram) }))
-    .find(({ gram, at }) => at === undefined || hasPredicate(gram, at, doc.lengthUnit));
+    .map(([key, count]) => ({ key, count, at: tally.first.get(key) }))
+    .find(({ at }) => hasPredicate(at, doc.lengthUnit));
   if (worst === undefined) return [];
-  const at = worst.at;
+  const at = worst.at?.sentence;
   return [
     {
       rule: "ngram-repetition",
       severity: "info",
       line: 0,
       column: 0,
-      quote: at?.text.trim() ?? worst.gram,
-      values: { word: worst.gram, count: worst.count, limit: options.limit, offset: at?.span.start ?? 0 },
+      quote: at?.text.trim() ?? worst.key,
+      values: { word: worst.at?.gram ?? worst.key, count: worst.count, limit: options.limit, offset: at?.span.start ?? 0 },
     },
   ];
 };
@@ -200,15 +224,36 @@ 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.」）で、
  * 展開がその直後の文にあることが契約書では普通にある。見るのは語として現れた所だけ（CISA の中の CI は見ない）。
@@ -216,6 +261,13 @@ const acronymsOf = (doc: ProseDocument, notation: NotAcronymSpans): AcronymHit[]
 const isExpanded = (body: string, acronym: string, expandedAt: ExpandedAt): boolean =>
   [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}${EDGE_AFTER}`, "gu"))].some((match) => expandedAt(body, acronym, match.index));
 
+/**
+ * 見出しは文にならないので、見出しの中の展開（Maximum Envelope of Water (MEOW) runs）は見出しの文字列で探す。
+ * 見出しの括弧は添え書き（Your Own AI (LLM)、(Beta)）にも使うので、見出しの語から略語の文字が順に拾えるときだけ認める。
+ */
+const expandsInHeading = (heading: string, acronym: string, expandedAt: ExpandedAt): boolean =>
+  isExpanded(heading, acronym, expandedAt) && abbreviates(heading.replaceAll(acronym, " "), acronym);
+
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
 const notationOf = (doc: ProseDocument): NotAcronymSpans =>
@@ -226,7 +278,9 @@ const notationOf = (doc: ProseDocument): NotAcronymSpans =>
     usStates: patternsOf(doc, "us-state-code"),
     emphasis: patternsOf(doc, "emphasis-word"),
     divisions: patternsOf(doc, "numbered-division"),
+    abbreviatedLabels: patternsOf(doc, "abbreviated-label"),
     honorifics: patternsOf(doc, "honorific"),
+    titles: patternsOf(doc, "name-title"),
     dateTimeUnits: patternsOf(doc, "date-time-unit"),
   });
 
@@ -241,13 +295,16 @@ 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 headings = doc.sections.map((section) => section.heading);
+  const explainedAlone = (word: string): boolean =>
+    common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt) || headings.some((heading) => expandsInHeading(heading, 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",
@@ -316,7 +373,7 @@ export const dashDensity: Detector = (doc, options): Finding[] => {
   const hits = findIn(doc, DASH);
   const first = hits[0];
   const rate = density(doc, hits.length);
-  if (wordsOf(doc) < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+  if (wordsOf(doc) < MIN_DOCUMENT_LENGTH[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
   return [
     {
       rule: "no-em-dash",

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-tree.ts

@@ -4,11 +4,13 @@ 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";
+import { reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
+import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 
 const QUOTE_LENGTH = 80;
 
 /** 指摘の位置から行末までを引用する。条の見出しや参照を含む一行が、読み手の探す手がかりになる。 */
-const quoteAt = (source: string, offset: number): string => {
+export const quoteAt = (source: string, offset: number): string => {
   const end = source.indexOf("\n", offset);
   return source
     .slice(offset, end === -1 ? source.length : end)
@@ -96,3 +98,45 @@ export const totalMismatch: Detector = (doc): Finding[] =>
         quote: quoteAt(doc.source, issue.offset),
         values: { ...issue.values, offset: issue.offset },
       }));
+
+const datedSpans = (tree: NonNullable<ProseDocument["structure"]>): DatedSpan[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+
+const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
+  connectors: (doc.lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
+  openers: (doc.lexicons["range-opener"] ?? []).map((entry) => entry.pattern),
+  closers: (doc.lexicons["range-closer"] ?? []).map((entry) => entry.pattern),
+});
+
+/** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
+export const dateRangeReversed: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : reversedRanges(doc.source, datedSpans(doc.structure), rangeWordsOf(doc)).map((issue) => ({
+        rule: "date-range-reversed",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));
+
+const shareWordsOf = (doc: ProseDocument): ShareWords => ({
+  labels: (doc.lexicons["share-label"] ?? []).map((entry) => entry.pattern),
+  exceptions: (doc.lexicons["share-exception"] ?? []).map((entry) => entry.pattern),
+  units: (doc.lexicons["percent-unit"] ?? []).map((entry) => entry.pattern),
+  totalLabels: (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
+});
+
+/** 構成比や内訳の百分率の和が 100% にならない。割合の語と百分率の単位は言語パッケージの語彙表から取る。 */
+export const percentSumMismatch: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : percentSumMismatches(doc.source, amountsOf(doc.structure), shareWordsOf(doc)).map((issue) => ({
+        rule: "percent-sum-mismatch",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));

package/src/detectors/structure.ts

@@ -3,6 +3,8 @@ 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";
+import { bodySectionOf } from "../body-section.ts";
 
 /**
  * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
@@ -41,7 +43,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 +101,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日」）は前置きに数えない。木を作るのは、数えて上限を超えたときだけ。 */
@@ -110,12 +119,10 @@ const withoutDateStamps = (doc: ProseDocument, paragraphs: readonly Paragraph[])
 
 /**
  * 本題に入るまでが長い。業務文書では、読み手は結論を探しに来ている。
- *
- * 「本題」は最初の中見出し（深さ 2 以上）とする。表題（深さ 1）の直後から数えると、
- * 表題しか無い文書で全文が前置きになる。中見出しが無い文書では何も言わない。
+ * 「本題」は最初の中見出し。中見出しが無い文書では、rule が requires の headings で動かず、動かなかった理由が出る。
  */
 export const preambleLength: Detector = (doc, options): Finding[] => {
-  const body = doc.sections.find((section) => section.depth >= 2);
+  const body = bodySectionOf(doc.sections);
   if (body === undefined) return [];
   const all = preambleParagraphs(doc.paragraphs, body.span.start);
   if (all.length <= options.limit) return [];

package/src/detectors/superlative-name.ts

@@ -9,10 +9,13 @@ const joinsAsNoun = (previous: Token, token: Token | undefined): token is Token
 
 /** 空白も助詞も挟まずに続く名詞の連なり（最大|瞬間|風速）の最後の語。連なりが無ければ undefined。 */
 const lastJoined = (tokens: readonly Token[], at: number): Token | undefined => {
-  const previous = tokens[at - 1];
-  const token = tokens[at];
-  if (previous === undefined || !joinsAsNoun(previous, token)) return undefined;
-  return lastJoined(tokens, at + 1) ?? token;
+  let last: Token | undefined;
+  for (let index = at; ; index += 1) {
+    const previous = tokens[index - 1];
+    const token = tokens[index];
+    if (previous === undefined || !joinsAsNoun(previous, token)) return last;
+    last = token;
+  }
 };
 
 const measures = (noun: Token, quantities: Lexicon): boolean => quantities.some((entry) => entry.pattern === noun.surface);

package/src/detectors/superlative-scope.ts

@@ -48,9 +48,14 @@ const namedBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexic
 
 /** 最上級に続く名詞句の終わり。名詞が出るまでは修飾を、出た後は名詞の連なりを読む。 */
 export const phraseEnd = (tokens: readonly Token[], at: number, nounSeen = false): number => {
-  const token = tokens[at];
-  if (token === undefined || !(nounSeen ? NOUN_RUN : PREMODIFIER).has(token.pos)) return at;
-  return phraseEnd(tokens, at + 1, nounSeen || NOMINAL.has(token.pos));
+  let end = at;
+  let seen = nounSeen;
+  for (;;) {
+    const token = tokens[end];
+    if (token === undefined || !(seen ? NOUN_RUN : PREMODIFIER).has(token.pos)) return end;
+    seen ||= NOMINAL.has(token.pos);
+    end += 1;
+  }
 };
 
 /** 最上級 + 名詞句 + 範囲の語 + 名詞句（the best pizza in Chicago・the most famous of the sculptures）。 */