chaffjs 0.35.0 → 0.37.0

package/src/detectors/range-notation.ts

@@ -12,8 +12,20 @@ export type WrittenRange = { readonly offset: number; readonly written: string;
 const FULLWIDTH_OFFSET = 0xfee0;
 const NUMBER = "[0-9０-９]+(?:[.．][0-9０-９]+)?";
 
-/** 範囲のすぐ後ろ（空白一つまで）の単位や語。番号にも使う記号（ハイフン）は、これが続くときだけ範囲と読む。 */
-const UNIT_AFTER = /^\s?[\p{L}%％]/u;
+/** 範囲のすぐ後ろ（同じ行の空白一つまで）の単位や語。番号にも使う記号（ハイフン）は、これが続くときだけ範囲と読む。 */
+const UNIT_AFTER = /^[^\S\n]?[\p{L}%％]/u;
+
+/**
+ * 漢字の語に詰めて書いた番号の後ろに仮名が続けば、文書の番号（直資4－5ほか、課資3-1の）。範囲なら後ろは単位（約3-5日）で、
+ * 仮名で始まる単位（約3-5か月、3-5つ）は語彙表 range-kana-unit が言う。
+ */
+const CODE_BEFORE = /\p{Script=Han}$/u;
+const KANA_AFTER = /^[^\S\n]?(\p{Script=Hiragana}.*)/u;
+
+const isDocumentNumber = (lineBefore: string, after: string, kanaUnits: readonly string[]): boolean => {
+  const kana = KANA_AFTER.exec(after)?.[1];
+  return CODE_BEFORE.test(lineBefore) && kana !== undefined && !kanaUnits.some((unit) => kana.startsWith(unit));
+};
 
 /** 行の頭（見出しや箇条書きの印の後ろ）の「1-2」は節の番号、閉じ括弧のすぐ後ろの「(703) 292-7827」は電話番号。 */
 const LABEL_BEFORE = /(?:^\s*[#>*+|-][\s#>*+|-]*|\)\s?)$/u;
@@ -30,9 +42,15 @@ const halfWidth = (text: string): string => text.replace(/[０-９．]/gu, (char
 /**
  * 文字列の中の数の範囲。前後にさらに数が続く並び（日付 2026-10-02、電話番号、時刻 10:00、版 1.2-3）は範囲ではない。
  * 終わりが始まりより小さいもの（郵便番号 100-0001、試合の 3-2）も範囲ではない。ambiguous の記号は、後ろに単位や語が続き、
- * 前が番号の札（図 2-1、Section 1-2、NSF 13-542）でないときだけ。
+ * 前が番号の札（図 2-1、Section 1-2、NSF 13-542）でも文書の番号（直資4－5ほか）でもないときだけ。
  */
-export const rangesIn = (text: string, marks: readonly string[], ambiguous: readonly string[] = [], labels: readonly string[] = []): WrittenRange[] => {
+export const rangesIn = (
+  text: string,
+  marks: readonly string[],
+  ambiguous: readonly string[] = [],
+  labels: readonly string[] = [],
+  kanaUnits: readonly string[] = [],
+): WrittenRange[] => {
   if (marks.length === 0) return [];
   const joiner = marks
     .toSorted((left, right) => right.length - left.length)
@@ -46,9 +64,10 @@ export const rangesIn = (text: string, marks: readonly string[], ambiguous: read
     const from = Number(halfWidth(match.groups?.["from"] ?? ""));
     const to = Number(halfWidth(match.groups?.["to"] ?? ""));
     const mark = match.groups?.["mark"] ?? "";
-    const unitFollows = UNIT_AFTER.test(text.slice(match.index + match[0].length));
+    const after = text.slice(match.index + match[0].length);
     const lineBefore = text.slice(text.lastIndexOf("\n", match.index - 1) + 1, match.index);
-    return to > from && !LABEL_BEFORE.test(lineBefore) && (!ambiguous.includes(mark) || (unitFollows && !isNumberLabel(lineBefore, labels)))
+    const readsAsRange = UNIT_AFTER.test(after) && !isNumberLabel(lineBefore, labels) && !isDocumentNumber(lineBefore, after, kanaUnits);
+    return to > from && !LABEL_BEFORE.test(lineBefore) && (!ambiguous.includes(mark) || readsAsRange)
       ? [{ offset: match.index, written: match[0], form: mark }]
       : [];
   });
@@ -62,6 +81,7 @@ export const rangeNotation: Detector = (doc, options): Finding[] => {
     entries.map((entry) => entry.pattern),
     entries.filter((entry) => entry.group === "ambiguous").map((entry) => entry.pattern),
     ["figure-label", "numbered-division", "numbered-label"].flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)),
+    (doc.lexicons["range-kana-unit"] ?? []).map((entry) => entry.pattern),
   );
   const minority = formMinority(ranges, options.limit);
   if (minority === undefined) return [];

package/src/detectors/registry/kanji-compound-slip.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { kanjiCompoundSlip } from "../kanji-compound-slip.ts";
+
+export const detector: Detector = kanjiCompoundSlip;

package/src/detectors/registry/phrase-in-use.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { phraseInUse } from "../phrase-match.ts";
+
+export const detector: Detector = phraseInUse;

package/src/detectors/requirement-smell.ts

@@ -1,6 +1,11 @@
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
+import { entriesForGenre } from "../lexicon-genres.ts";
 import { entryCloses, entryIn, entryRanges } from "./lexicon-match.ts";
+import { classWordsOf, isClassCue, namesClassAfter } from "./open-end-class.ts";
+import { glossesCondition } from "./open-end-condition.ts";
 import { openEndAt, openEndNames, type OpenEndNames } from "./open-end-names.ts";
+import { asksAfter, questionWordsOf } from "./open-end-question.ts";
+import { isScopeCue, openOnPurpose, scopeWordsOf } from "./open-end-scope.ts";
 import { statesConcrete } from "./vague-deadline.ts";
 
 // Requirements smells (Femmer et al. 2017; Berry et al. 2003; ISO/IEC/IEEE 29148): a loophole, an open-ended list and
@@ -9,6 +14,10 @@ import { statesConcrete } from "./vague-deadline.ts";
 
 const OPEN_END = "requirement-open-end";
 const LOOPHOLE = "requirement-loophole";
+/** The words of a question that an open list gives example answers to. */
+const OPEN_QUESTION = "requirement-open-question";
+/** The words of a condition whose bracketed examples an open list may give. */
+const OPEN_CONDITION = "requirement-open-condition";
 const TIME = "time";
 const CONCRETE_DEADLINE = "concrete-deadline";
 
@@ -56,30 +65,58 @@ const boundedInTime = (doc: ProseDocument, sentence: Sentence, entry: LexiconEnt
     (doc.lexicons[CONCRETE_DEADLINE] ?? []).map((limit) => limit.pattern),
   );
 
-/** Where the word stands as a smell. An open-end word inside a name the document gives (業務執行取締役等) is none; without tokens it cannot be told apart. */
+/**
+ * A lexicon's words that hold in the document's genre ("but not limited to" is a term of art in a contract); the open-end
+ * lexicon also holds the cues of a class named after the list and of what holds it, which are no smell.
+ */
+const smellWords = (doc: ProseDocument, lexicon: string, genre: string | undefined): LexiconEntry[] =>
+  entriesForGenre(doc.lexicons[lexicon] ?? [], genre).filter((entry) => !isClassCue(entry) && !isScopeCue(entry));
+
+/**
+ * Where the word stands as a smell. An open-end word inside a name the document gives (業務執行取締役等), giving examples
+ * of a class named right after it (印刷等、二次的に利用), or ending a list a condition, a permission or a prohibition holds
+ * (転載等をしてはならない), is none; without tokens none of these can be told apart.
+ */
 const smellAt = (doc: ProseDocument, sentence: Sentence, entry: LexiconEntry, lexicon: string, names: () => OpenEndNames): number | undefined => {
   if (!entryIn(sentence, entry) || boundedInTime(doc, sentence, entry, lexicon)) return undefined;
   const tokenized = sentence.tokens !== undefined && (entry.tokens?.length ?? 0) > 0;
-  return lexicon === OPEN_END && tokenized ? openEndAt(doc, sentence, entry, names()) : offsetOf(sentence, entry);
+  if (lexicon !== OPEN_END || !tokenized) return offsetOf(sentence, entry);
+  const classWords = classWordsOf(doc.lexicons[OPEN_END] ?? []);
+  const scopeWords = scopeWordsOf(doc.lexicons[OPEN_END] ?? []);
+  return openEndAt(doc, sentence, entry, names(), (tokens, range) => namesClassAfter(tokens, range, classWords) || openOnPurpose(tokens, range, scopeWords));
 };
 
+/** An open list right before a question the reader answers (…措置など、どのような措置を求めるのか): its items are example answers. */
+const answersQuestion = (doc: ProseDocument, sentence: Sentence, entry: LexiconEntry, lexicon: string, offset: number): boolean =>
+  lexicon === OPEN_END && asksAfter(sentence, offset + entry.pattern.length, questionWordsOf(doc.lexicons[OPEN_QUESTION] ?? []));
+
+/** An open list in brackets right after a condition word (場合（単一テーブルへの SELECT 等）): examples of when, not of what. */
+const glossesConditionAt = (doc: ProseDocument, sentence: Sentence, lexicon: string, offset: number): boolean =>
+  lexicon === OPEN_END &&
+  glossesCondition(
+    sentence,
+    offset,
+    (doc.lexicons[OPEN_CONDITION] ?? []).map((entry) => entry.pattern),
+  );
+
 /** The first word of each smell in one requirement sentence: one finding per smell, not per word. */
-const smellsIn = (doc: ProseDocument, sentence: Sentence, names: () => OpenEndNames): Finding[] =>
+const smellsIn = (doc: ProseDocument, sentence: Sentence, genre: string | undefined, names: () => OpenEndNames): Finding[] =>
   SMELLS.flatMap(({ lexicon, variant }) =>
-    (doc.lexicons[lexicon] ?? [])
+    smellWords(doc, lexicon, genre)
       .flatMap((entry) => {
         const offset = smellAt(doc, sentence, entry, lexicon, names);
-        return offset === undefined ? [] : [findingOf(sentence, entry, variant, offset)];
+        const examples = offset !== undefined && (answersQuestion(doc, sentence, entry, lexicon, offset) || glossesConditionAt(doc, sentence, lexicon, offset));
+        return offset === undefined || examples ? [] : [findingOf(sentence, entry, variant, offset)];
       })
       .slice(0, 1),
   );
 
-export const requirementSmell: Detector = (doc): Finding[] => {
+export const requirementSmell: Detector = (doc, options): Finding[] => {
   const markers = doc.lexicons[MARKERS] ?? [];
   const notMarkers = doc.lexicons[NOT_MARKERS] ?? [];
   const statements = (doc.lexicons[STATEMENTS] ?? []).map((entry) => entry.pattern);
   // Read once, and only when a requirement has an open-end word to tell apart from a name.
   const cache: { names?: OpenEndNames } = {};
-  const names = (): OpenEndNames => (cache.names ??= openEndNames(doc, doc.lexicons[OPEN_END] ?? [], statements));
-  return doc.sentences.filter((sentence) => isRequirement(sentence, markers, notMarkers)).flatMap((sentence) => smellsIn(doc, sentence, names));
+  const names = (): OpenEndNames => (cache.names ??= openEndNames(doc, smellWords(doc, OPEN_END, options.genre), statements));
+  return doc.sentences.filter((sentence) => isRequirement(sentence, markers, notMarkers)).flatMap((sentence) => smellsIn(doc, sentence, options.genre, names));
 };

package/src/detectors/scaled-figure-unit.ts

@@ -0,0 +1,103 @@
+// number-without-unit, in prose: a number written with a word of scale and no unit (83,494百万, 83 million) where the
+// document writes that word of scale with one unit many times and without one nowhere else (83,494百万円, $83 million).
+// Pure; the words of scale, the currency marks and the joiners come from the language's lexicons.
+import { escapeRegExp } from "../orthography.ts";
+import type { CurrencyForm } from "./currency-notation.ts";
+import { AMOUNT } from "./currency-notation.ts";
+
+/** A number with a word of scale: from its currency mark (if any) to the end of its unit, and the unit ("" when bare). */
+export type ScaledFigure = { readonly offset: number; readonly end: number; readonly written: string; readonly scale: string; readonly unit: string };
+
+export type ScaleWords = { readonly scales: readonly string[]; readonly forms: readonly CurrencyForm[]; readonly joiners: readonly string[] };
+
+export type ScaleGap = { readonly figure: ScaledFigure; readonly unit: string };
+
+/** How many numbers must carry the unit before the one without it reads as a slip rather than a way of writing. */
+export const MIN_WITH_UNIT = 5;
+
+const LATIN = /[A-Za-z]/u;
+const longestFirst = (words: readonly string[]): string[] => words.toSorted((left, right) => right.length - left.length);
+
+const figurePattern = (scales: readonly string[]): RegExp => {
+  const scale = longestFirst(scales)
+    .map((word) => `${escapeRegExp(word)}${LATIN.test(word) ? "(?![A-Za-z])" : ""}`)
+    .join("|");
+  return new RegExp(`(?<![\\w.,，．０-９])${AMOUNT}\\s?(?:${scale})`, "gu");
+};
+
+const formMatches = (text: string, pattern: string, side: "before" | "after"): boolean => {
+  if (side === "before") return text.endsWith(pattern) && !(LATIN.test(pattern.charAt(0)) && LATIN.test(text.charAt(text.length - pattern.length - 1)));
+  return text.startsWith(pattern) && !(LATIN.test(pattern.at(-1) ?? "") && LATIN.test(text.charAt(pattern.length)));
+};
+
+/** The currency mark written before a number ($, US$, ¥), with the one space it may have. */
+const markBefore = (text: string, offset: number, forms: readonly CurrencyForm[]): string => {
+  const before = text.slice(Math.max(0, offset - 8), offset);
+  const spaced = before.endsWith(" ") ? before.slice(0, -1) : before;
+  const form = longestFirst(forms.filter((entry) => entry.position === "before").map((entry) => entry.pattern)).find((pattern) =>
+    formMatches(spaced, pattern, "before"),
+  );
+  if (form === undefined) return "";
+  return spaced === before ? form : `${form} `;
+};
+
+/** What follows a word of scale as its unit: a currency word (円, dollars), else the next word ("people", 人, ドル); "" when none. */
+const unitAfter = (rest: string, forms: readonly CurrencyForm[]): string => {
+  const spaced = rest.startsWith(" ") ? rest.slice(1) : rest;
+  const form = longestFirst(forms.filter((entry) => entry.position === "after").map((entry) => entry.pattern)).find((pattern) =>
+    formMatches(spaced, pattern, "after"),
+  );
+  const word = form ?? /^(?:[A-Za-z]+|[\p{Script=Katakana}ー]+|\p{Script=Han})/u.exec(spaced)?.[0];
+  if (word === undefined) return "";
+  return spaced === rest ? word : ` ${word}`;
+};
+
+const figureAt = (text: string, match: RegExpExecArray, words: ScaleWords): ScaledFigure | undefined => {
+  const end = match.index + match[0].length;
+  const rest = text.slice(end);
+  if (/^\s?[0-9０-９]/u.test(rest)) return undefined;
+  const mark = markBefore(text, match.index, words.forms);
+  const after = mark === "" ? unitAfter(rest, words.forms) : "";
+  const scale = longestFirst(words.scales).find((word) => match[0].endsWith(word)) ?? "";
+  return { offset: match.index - mark.length, end: end + after.length, written: match[0], scale, unit: (mark || after).trim() };
+};
+
+/** Every number with a word of scale in a text, in order; one that runs on into another number (1億2,000万円) is left out. */
+export const scaledFiguresIn = (text: string, words: ScaleWords): ScaledFigure[] =>
+  words.scales.length === 0 ? [] : [...text.matchAll(figurePattern(words.scales))].flatMap((match) => figureAt(text, match, words) ?? []);
+
+/** A bare number joined to its neighbour by a range or list word, so that one unit serves both (100百万〜200百万円). */
+const sharesUnit = (text: string, left: ScaledFigure | undefined, right: ScaledFigure | undefined, joiners: readonly string[]): boolean => {
+  if (left === undefined || right === undefined) return false;
+  const gap = text.slice(left.end, right.offset).trim();
+  return gap === "" || joiners.includes(gap) || joiners.includes(gap.toLowerCase());
+};
+
+const gapOfScale = (text: string, figures: readonly ScaledFigure[], joiners: readonly string[]): ScaleGap[] => {
+  const bare = figures.filter(
+    (figure, index) => figure.unit === "" && !sharesUnit(text, figure, figures[index + 1], joiners) && !sharesUnit(text, figures[index - 1], figure, joiners),
+  );
+  const withUnit = figures.filter((figure) => figure.unit !== "");
+  const units = new Set(withUnit.map((figure) => figure.unit));
+  const [unit] = units;
+  const [figure] = bare;
+  if (figure === undefined || unit === undefined || bare.length !== 1 || units.size !== 1 || withUnit.length < MIN_WITH_UNIT) return [];
+  return [{ figure, unit }];
+};
+
+/**
+ * The one bare number of a word of scale whose other numbers all carry one unit, at least MIN_WITH_UNIT times. Two bare
+ * numbers, or two units (百万円 and 百万株), and the document is read as writing the word that way on purpose.
+ */
+export const scaleGaps = (text: string, figures: readonly ScaledFigure[], joiners: readonly string[]): ScaleGap[] => {
+  const scales = [...new Set(figures.map((figure) => figure.scale))];
+  return scales
+    .flatMap((scale) =>
+      gapOfScale(
+        text,
+        figures.filter((figure) => figure.scale === scale),
+        joiners,
+      ),
+    )
+    .toSorted((left, right) => left.figure.offset - right.figure.offset);
+};

package/src/detectors/sentence-counts.ts

@@ -1,4 +1,5 @@
-import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence, Token } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
 import { isWithinAny, quotedIn } from "../quoted-span.ts";
 import { entryOpens } from "./lexicon-match.ts";
 
@@ -6,10 +7,25 @@ type TokenTest = (token: Token, at: number, tokens: readonly Token[]) => boolean
 
 const wordsOf = (lexicon: Lexicon | undefined): ReadonlySet<string> => new Set((lexicon ?? []).map((entry) => entry.pattern));
 
-/** The tokens of a sentence that pass the test, outside anything quoted in 「」『』: a quotation is not the writer's to rephrase. */
-const countedTokens = (sentence: Sentence, test: TokenTest): Token[] => {
-  const quoted = quotedIn(sentence);
-  return (sentence.tokens ?? []).filter((token, at, tokens) => test(token, at, tokens) && !isWithinAny(quoted, token.span));
+/** The terms whose counted word belongs to the term itself (電磁的方法), not to the writer's style. */
+export const FIXED_TERM_LEXICON = "teki-fixed-term";
+
+/** Where the sentence holds one of the terms, in the document's coordinates. */
+const termSpans = (sentence: Sentence, terms: Lexicon): Span[] =>
+  terms.flatMap((entry) =>
+    [...sentence.text.matchAll(new RegExp(escapeRegExp(entry.pattern), "gu"))].map((match) => ({
+      start: sentence.span.start + match.index,
+      end: sentence.span.start + match.index + entry.pattern.length,
+    })),
+  );
+
+/**
+ * The tokens of a sentence that pass the test, outside anything quoted in 「」『』 and outside the fixed terms: neither a
+ * quotation nor a term the law defines (電磁的方法) is the writer's to rephrase.
+ */
+const countedTokens = (sentence: Sentence, test: TokenTest, fixedTerms: Lexicon): Token[] => {
+  const kept = [...quotedIn(sentence), ...termSpans(sentence, fixedTerms)];
+  return (sentence.tokens ?? []).filter((token, at, tokens) => test(token, at, tokens) && !isWithinAny(kept, token.span));
 };
 
 const findingOf = (sentence: Sentence, counted: readonly Token[], limit: number): Finding => ({
@@ -21,16 +37,16 @@ const findingOf = (sentence: Sentence, counted: readonly Token[], limit: number)
   values: { word: counted[0]?.surface ?? "", count: counted.length, limit, offset: sentence.span.start },
 });
 
-const sentencesOver = (doc: ProseDocument, limit: number, test: TokenTest): Finding[] =>
+const sentencesOver = (doc: ProseDocument, limit: number, test: TokenTest, fixedTerms: Lexicon = []): Finding[] =>
   doc.sentences.flatMap((sentence) => {
-    const counted = countedTokens(sentence, test);
+    const counted = countedTokens(sentence, test, fixedTerms);
     return counted.length > limit ? [findingOf(sentence, counted, limit)] : [];
   });
 
 /** A sentence holding more than limit tokens written as one of the lexicon's words (the suffix 的). */
 export const sentenceWordCount: Detector = (doc, options): Finding[] => {
   const words = wordsOf(options.lexicon);
-  return sentencesOver(doc, options.limit, (token) => words.has(token.surface));
+  return sentencesOver(doc, options.limit, (token) => words.has(token.surface), doc.lexicons[FIXED_TERM_LEXICON] ?? []);
 };
 
 const NOMINAL: ReadonlySet<string> = new Set(["NOUN", "PROPN", "NUM"]);
@@ -53,9 +69,39 @@ const itemEndBefore = (at: number, tokens: readonly Token[]): number => {
 /** The index of the token the next item starts with, past spaces. */
 const itemStartAfter = (at: number, tokens: readonly Token[]): number => tokens.findIndex((token, index) => index > at && !isSpace(token));
 
-/** A comma between two nouns separates listed items (名前、会社名、連絡先), not clauses. A bracketed note after an item is part of it. */
+/** A prefix bound to the noun after it (第I, 各部署) starts a noun. */
+const isBoundPrefix = (token: Token | undefined): boolean => token?.features?.["Bound"] === "Yes" && token.pos === "ADJ";
+
+const startsNoun = (at: number, tokens: readonly Token[]): boolean => {
+  const start = itemStartAfter(at, tokens);
+  return isNominal(tokens[start]) || (isBoundPrefix(tokens[start]) && isNominal(tokens[start + 1]));
+};
+
+const QUOTE_CLOSERS: ReadonlySet<string> = new Set(["」", "』"]);
+const QUOTE_OPENERS: ReadonlySet<string> = new Set(["「", "『"]);
+
+/** Whether the token at `closer` closes a quotation of a noun phrase (「技術の確立」), not of a clause (「成功した」). */
+const closesNounQuotation = (closer: number, tokens: readonly Token[]): boolean =>
+  QUOTE_CLOSERS.has(tokens[closer]?.surface ?? "") && isNominal(tokens[closer - 1]);
+
+/**
+ * A comma from one quoted noun phrase straight to the next (「計画」、「予算」) lists quoted items. A noun before a quotation
+ * (対応するもの、「A」に関しては) may end a clause, and so may a quoted clause, so only noun quotation to noun quotation counts.
+ */
+const betweenQuotations = (at: number, tokens: readonly Token[]): boolean => {
+  const before = tokens.findLastIndex((token, index) => index < at && !isSpace(token));
+  const start = itemStartAfter(at, tokens);
+  if (!QUOTE_OPENERS.has(tokens[start]?.surface ?? "")) return false;
+  const after = tokens.findIndex((token, index) => index > start && QUOTE_CLOSERS.has(token.surface));
+  return closesNounQuotation(before, tokens) && closesNounQuotation(after, tokens);
+};
+
+/**
+ * A comma between two nouns separates listed items (名前、会社名、連絡先), not clauses. A bracketed note after an item is part of
+ * it, a noun after its prefix (第I、第II) is a noun, and so is a quotation listed next to another.
+ */
 export const separatesItems = (at: number, tokens: readonly Token[]): boolean =>
-  isNominal(tokens[itemEndBefore(at, tokens)]) && isNominal(tokens[itemStartAfter(at, tokens)]);
+  betweenQuotations(at, tokens) || (isNominal(tokens[itemEndBefore(at, tokens)]) && startsNoun(at, tokens));
 
 /** A sentence cut by more than limit of the lexicon's commas (読点). Commas between listed nouns are not counted. */
 export const sentenceCommaCount: Detector = (doc, options): Finding[] => {
@@ -65,10 +111,16 @@ export const sentenceCommaCount: Detector = (doc, options): Finding[] => {
 
 const CONJUNCTIVE = "SCONJ";
 
-/** A sentence joining more than limit clauses with the lexicon's conjunctive particle (逆接の「が」), not the same word as a case particle. */
+/** The phrases ending in a prefatory が (繰り返しになりますが、〜の件でありますが): no contrast with what follows. */
+export const PREFATORY_LEXICON = "adversative-ga-prefatory";
+
+/**
+ * A sentence joining more than limit clauses with the lexicon's conjunctive particle (逆接の「が」), not the same word as a
+ * case particle, and not inside a prefatory phrase.
+ */
 export const sentenceConjunctiveCount: Detector = (doc, options): Finding[] => {
   const words = wordsOf(options.lexicon);
-  return sentencesOver(doc, options.limit, (token) => token.pos === CONJUNCTIVE && words.has(token.surface));
+  return sentencesOver(doc, options.limit, (token) => token.pos === CONJUNCTIVE && words.has(token.surface), doc.lexicons[PREFATORY_LEXICON] ?? []);
 };
 
 type Opened = { readonly sentence: Sentence; readonly opener: string | undefined };

package/src/detectors/sentence-ending.ts

@@ -1,7 +1,9 @@
 import { endingTokens, isClosed } from "../sentence-shape.ts";
 import { enumeratedRuns, enumeratorStarts, numberedStarts } from "./enumerated-runs.ts";
-import { continuesInto, groupOf, registerOf, slipsOf, type Register } from "./register.ts";
+import { continuesInto, groupOf, majorityOf, registerOf, slipsOf, type Register } from "./register.ts";
 import { isRunInLabel } from "./run-in-label.ts";
+import { noticeSentences } from "./notice-paragraph.ts";
+import { chronologyRows } from "../chronology-rows.ts";
 import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
 
 /**
@@ -10,6 +12,8 @@ import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } f
  * どちらが正しいかは決めない。決めると、方針の違う書き手にそのまま無視される。
  * 見るのは文書の中での一貫性だけで、少数派のほうを指摘する。spec §12.3 の方針を日本語にも。
  * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）と、項目や段落の頭の太字の札（**速く書ける。**）は文として数えない。
+ * 年表の行（1921年信号装置の製作を開始する。）も、文書の文体と揃えない書き方なので数えない。
+ * 断り書きの段落（…ご了承ください。）も、本文とは別の声で書く決まり文句なので数えない（notice-paragraph.ts）。
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
@@ -35,11 +39,16 @@ const runsOf = (doc: ProseDocument, registers: readonly Register[]): Span[] => {
 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]) || isRunInLabel(doc.source, sentence.span)) return [];
+  const rows = chronologyRows(doc);
+  const all = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
+    if (!isClosed(sentence) || rows.has(sentence) || continuesInto(sentence, doc.sentences[index + 1]) || isRunInLabel(doc.source, sentence.span)) return [];
     const register = registerOfSentence(sentence, polite, neutral);
     return register === undefined ? [] : [{ sentence, register }];
   });
+  const registers = new Map(all.map((entry) => [entry.sentence, entry.register]));
+  const majority = majorityOf(all.map((entry) => ({ register: entry.register, group: undefined })));
+  const notices = noticeSentences(doc.paragraphs, doc.lexicons["notice-phrase"] ?? [], (sentence) => registers.get(sentence), majority);
+  const found = all.filter((entry) => !notices.has(entry.sentence));
   const runs = runsOf(
     doc,
     found.map((entry) => entry.register),

package/src/detectors/sentence-length.ts

@@ -1,26 +1,39 @@
 import { lengthOf, proseText } from "../measure.ts";
 import type { Detector, DetectorOptions, Finding, LengthUnit, Sentence } from "../plugin.ts";
+import { citationLead } from "./citation-sentence.ts";
 import { pageMarkerPattern, pageMarkerSize } from "./page-marker.ts";
 
 type Measure = { readonly size: number; readonly limit: number; readonly variant?: string };
 
+/** The page markers' pattern and the citation signals ("see"), read once per document. */
+type SentenceWords = { readonly markers: RegExp | undefined; readonly citationSignals: readonly string[] };
+
+const sizeOf = (text: string, unit: LengthUnit): number =>
+  unit === "word" ? text.split(/\s+/u).filter((word) => word.length > 0).length : text.replace(/\s+/gu, "").length;
+
 /**
  * 文書と違う言語の文（和文の中の英文）は、その言語の単位と上限で測る。rule がその言語の段を持たなければ文書のもので。
  * 印刷版のページの印（( printed page 52044)）は文の言葉ではないので数えない。
+ * 脚注の文献の記載（著者 (2025), "題," …）も書き手の文ではないので、その前に書き手が置いた言葉（For example, see …）だけを測る。
  */
-const measureOf = (sentence: Sentence, unit: LengthUnit, options: DetectorOptions, markers: RegExp | undefined): Measure => {
+const measureOf = (sentence: Sentence, unit: LengthUnit, options: DetectorOptions, words: SentenceWords): Measure => {
+  const lead = citationLead(proseText(sentence), words.citationSignals);
+  if (lead !== undefined) return { size: sizeOf(lead, unit), limit: options.limit };
   const embedded = sentence.embeddedLanguage;
   const limit = embedded === undefined ? undefined : options.embeddedLimits?.[embedded.id];
   if (embedded === undefined || limit === undefined) {
-    return { size: lengthOf(sentence, unit) - pageMarkerSize(proseText(sentence), markers, unit), limit: options.limit };
+    return { size: lengthOf(sentence, unit) - pageMarkerSize(proseText(sentence), words.markers, unit), limit: options.limit };
   }
   return { size: lengthOf(sentence, embedded.lengthUnit), limit, variant: `embedded-${embedded.id}` };
 };
 
 export const sentenceLength: Detector = (doc, options): Finding[] => {
-  const markers = pageMarkerPattern((options.lexicon ?? []).map((entry) => entry.pattern));
+  const words: SentenceWords = {
+    markers: pageMarkerPattern((options.lexicon ?? []).map((entry) => entry.pattern)),
+    citationSignals: (doc.lexicons["citation-signal"] ?? []).map((entry) => entry.pattern),
+  };
   return doc.sentences
-    .map((sentence) => ({ sentence, measure: measureOf(sentence, doc.lengthUnit, options, markers) }))
+    .map((sentence) => ({ sentence, measure: measureOf(sentence, doc.lengthUnit, options, words) }))
     .filter(({ measure }) => measure.size > measure.limit)
     .map(({ sentence, measure }) => ({
       rule: "max-sentence-length",

package/src/detectors/sentence-load.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
 import { proseText } from "../measure.ts";
 import { quotedSpans } from "../quoted-span.ts";
+import { literalCues, withoutLiteralQuotes } from "../literal-quote.ts";
 import { bracketDepth, clauseCount, topicDistance } from "../sentence-load.ts";
 
 const findingOf = (sentence: Sentence, count: number, limit: number): Finding => ({
@@ -35,8 +36,14 @@ const ownTokens = (sentence: Sentence): Token[] => {
   return (sentence.tokens ?? []).filter((token) => !inQuote(token));
 };
 
-/** Brackets inside brackets: 「（注（a）参照）」. The depth is read from the text, so it works in every language. */
-export const bracketNesting: Detector = overLimit((sentence) => bracketDepth(sentence.text));
+/**
+ * Brackets inside brackets: 「（注（a）参照）」. The depth is read from the text, so it works in every language. A quotation of a
+ * string to type as it stands (件名に「応募（総務課）」と記載) counts as one bracket: its own brackets cannot be taken out.
+ */
+export const bracketNesting: Detector = (doc, options) => {
+  const cues = literalCues(doc.lexicons["literal-quote-cue"] ?? []);
+  return overLimit((sentence) => bracketDepth(withoutLiteralQuotes(sentence.text, cues)))(doc, options);
+};
 
 /** Clauses chained in one sentence (調べて、まとめ、報告したが、返事がないので、…). Needs the language's tokens. */
 export const clauseChain: Detector = overLimit((sentence) => (sentence.tokens === undefined ? undefined : clauseCount(ownTokens(sentence))));