chaffjs 0.36.0 → 0.37.0

package/src/detectors/name-variant.ts

@@ -24,6 +24,9 @@ import { isOrdinaryToken, withOrdinaryWords } from "../name-ordinary-word.ts";
 import { isInPersonField } from "../person-field.ts";
 import { labelledSpans, orderNamesOf, quotedSpans, stemOf, titleCaseSpans, wordOrderVariants, type OrderWord } from "../name-word-order.ts";
 import { isGroupPairOf, notDefinedTerms, outsideCapitals, sentenceIndexOf, withGivenNames } from "./name-variant-apart.ts";
+import { usualIsMisspelt } from "../name-misspelt-usual.ts";
+import { spellerOf } from "./unknown-word.ts";
+import { isKnownWord } from "../spelling.ts";
 
 // 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
 // （です、まで）は name-particle、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
@@ -387,7 +390,10 @@ export const nameVariant: Detector = (doc): Finding[] => {
   const withProducts = [...withPlaces, ...productFindings(doc, prose, withPlaces)];
   const withOrder = [...withProducts, ...orderFindings(doc, prose, withProducts)];
   const codes = modelCodeFindings(doc, prose).filter((code) => !overlapsAny(withOrder, code.offset, code.name.length));
+  const dictionary = doc.dictionary?.();
+  const speller = dictionary === undefined ? undefined : spellerOf(doc, dictionary);
   return [...withOrder, ...codes]
+    .filter(({ name, usual }) => speller === undefined || !usualIsMisspelt(name, usual, (word) => isKnownWord(word, speller)))
     .toSorted((left, right) => left.offset - right.offset)
     .map(({ offset, name, usual, kind }) => ({
       rule: "",

package/src/detectors/organisation-run.ts

@@ -86,10 +86,15 @@ const endsInForm = (text: string, closingForms: readonly string[]): boolean =>
  * または組織の語で閉じる区切りが 2 つ以上続くもの（国土交通省鉄道局総務課）。
  * 組織の語で閉じない連なり（情報処理推進機構認定試験、総務課長）や、頭に名前の無い 1 区切り（個人情報保護法施行規則改正案検討会）は名前ではない。
  */
+/** 尻の法人格（独立行政法人）の前が、組織の語で閉じる区切りだけに割れるか（文部科学省独立行政法人: 所管の組織と法人の種類）。 */
+const segmentsBeforeForm = (run: readonly Token[], words: OrganisationWords): boolean =>
+  run.some((_, at) => at > 0 && words.closingForms.includes(surfaceOf(run.slice(at))) && segmentCount(run.slice(0, at), words.units) >= 1);
+
 export const isOrganisationRun = (tokens: readonly Token[], covering: readonly number[], words: OrganisationWords): boolean => {
   const run = contiguous(tokens, withClosingUnit(tokens, covering, words.units));
   if (run === undefined || run.length === 0) return false;
-  if (endsInForm(surfaceOf(run), words.closingForms) && run.some(isProperPiece) && !run.some(isNumber)) return true;
+  const named = run.some(isProperPiece) || segmentsBeforeForm(run, words);
+  if (endsInForm(surfaceOf(run), words.closingForms) && named && !run.some(isNumber)) return true;
   const form = formLength(run, new Set(words.forms));
   const head = form > 0 ? form : properLength(run);
   const segments = segmentCount(run.slice(head), words.units);

package/src/detectors/orthographic-variant.ts

@@ -17,6 +17,7 @@ import { wholeWordRuns, type WholeWordRun } from "../whole-word-runs.ts";
 import { entriesForGenre } from "../lexicon-genres.ts";
 import { asNounWhereNominal, documentNounKeys } from "../nominal-stem.ts";
 import { isCompoundHead } from "../compound-head.ts";
+import { leadingLabelSpans } from "../leading-label.ts";
 
 /**
  * A word found in the document: where it is, which sentence it is in, its key and spelling, how it is written when that differs, and
@@ -49,6 +50,14 @@ const FUKUSHI = "hiragana-fukushi";
 const IDIOM = "orthographic-variant-idiom";
 /** Lexicon: verbs whose て-form opening a sentence before a comma is a conjunction (あわせて、). */
 const CONJUNCTION = "orthographic-variant-conjunction";
+/** Lexicon: verbs whose judging use (〜とみられる, 増加がみられる) is written in kana while the verb (資料を見る) keeps its kanji. */
+const JUDGING = "orthographic-variant-judging";
+/**
+ * Lexicon: words whose kanji is also a person (方 as かた): compared only before が or で (早いほうが, 資料のほうで), where the
+ * person is rare; before に, の or は (担当の方に) the kanji is mostly the person.
+ */
+const COMPARATIVE = "orthographic-variant-comparative";
+const COMPARATIVE_PARTICLES = new Set(["が", "で"]);
 /** Lexicon: words the tokenizer cuts in one spelling and not the other (お客様, お客 and さま). Each is read whole, keyed by its group. */
 const WHOLE_WORD = "orthographic-variant-whole-word";
 /** Lexicon: suffixes written onto a word that do not make a compound of it (割当て等, 引受け後): the word keeps its okurigana there. */
@@ -68,8 +77,9 @@ const inSentence = (sentence: Sentence, spans: readonly Span[]): Span[] =>
   spans.map((span) => ({ start: span.start - sentence.span.start, end: span.end - sentence.span.start }));
 
 /**
- * Whether a stretch of the sentence is outside a quotation, the team's names, a company's name (関東珪曹硝子㈱) and a reading in
- * brackets (HTTP（えいちてぃーてぃーぴー）): the first three keep their own spelling, and a reading is not a spelling at all.
+ * Whether a stretch of the sentence is outside a quotation, the team's names, a company's name (関東珪曹硝子㈱), a reading in
+ * brackets (HTTP（えいちてぃーてぃーぴー）) and a label opening the sentence (（答）): the first three keep their own spelling,
+ * a reading is not a spelling at all, and a label is a fixed short form.
  */
 const isOpenIn = (sentence: Sentence, names: Names): IsOpen => {
   const closed = [
@@ -77,6 +87,7 @@ const isOpenIn = (sentence: Sentence, names: Names): IsOpen => {
     ...furiganaSpans(sentence.text),
     ...japaneseCompanyNameSpans(sentence.text, names.companyForms),
     ...inSentence(sentence, names.linkTitles),
+    ...leadingLabelSpans(sentence.text),
   ];
   const named = nameSpans(sentence.text, names.team);
   return (start, end) => !isWithinAny(closed, { start, end }) && !touchesAny(named, start, end);
@@ -140,18 +151,37 @@ const isConjunctionUse = ({ token, previous, following }: InContext, conjunction
   TE.has(following?.[0]?.surface ?? "") &&
   COMMA.has(following?.[1]?.surface ?? "");
 
-/** The lexicons that set a verb's use apart: idioms (気をつける) and conjunctions (あわせて、). */
-type Uses = { readonly idioms: ReadonlySet<string>; readonly conjunctions: ReadonlySet<string> };
+/** と, or と and は or も (〜ともみられる): the quotative particle before a verb of judging. */
+const QUOTATIVE = "と";
+const QUOTATIVE_TOPIC = new Set(["は", "も"]);
+const PASSIVE = new Set(["られる", "れる"]);
+
+const followsQuotative = (previous: Token | undefined, before: Token | undefined): boolean =>
+  previous?.pos === "ADP" && (previous.surface === QUOTATIVE || (QUOTATIVE_TOPIC.has(previous.surface) && before?.surface === QUOTATIVE));
+
+/** The particles of the subject before an observing られる (増加がみられる, 発生はみられない); after を it is looking (映画を見られる). */
+const OBSERVED_SUBJECT = new Set(["が", "は", "も"]);
+
+const isObserved = (previous: Token | undefined, following: readonly Token[] | undefined): boolean =>
+  previous?.pos === "ADP" && OBSERVED_SUBJECT.has(previous.surface) && PASSIVE.has(following?.[0]?.lemma ?? "");
+
+/** A listed verb after the quotative と (〜とみる) or observing with られる (増加がみられる): judging what is seen, not looking. */
+const isJudgingUse = ({ token, previous, before, following }: InContext, judging: ReadonlySet<string>): boolean =>
+  token.pos === "VERB" && judging.has(token.lemma ?? "") && (followsQuotative(previous, before) || isObserved(previous, following));
+
+/** The lexicons that set a verb's use apart: idioms (気をつける), conjunctions (あわせて、) and judging (〜とみられる). */
+type Uses = { readonly idioms: ReadonlySet<string>; readonly conjunctions: ReadonlySet<string>; readonly judging: ReadonlySet<string> };
 
 /**
  * A helper verb or a dependent noun (見て下さい, その事) is written kana by many guides while the full word keeps its kanji (資料を下さい).
  * The two uses are compared apart, so a document that follows that convention is consistent. A suffix (業務用, 全員ぶん) is a third use:
  * it is not the dependent noun of the same reading (このように). The verb of an idiom (気をつける) is a fourth, and a
- * て-form used as a conjunction (あわせて、) a fifth.
+ * て-form used as a conjunction (あわせて、) a fifth, and a verb of judging (〜とみられる) a sixth.
  */
-const useOf = (word: InContext, { idioms, conjunctions }: Uses): string => {
+const useOf = (word: InContext, { idioms, conjunctions, judging }: Uses): string => {
   if (isIdiomVerb(word, idioms)) return "idiom";
   if (isConjunctionUse(word, conjunctions)) return "conjunction";
+  if (isJudgingUse(word, judging)) return "judging";
   if (isKanaSuffix(word)) return "suffix";
   if (!isHelper(word)) return "free";
   return word.token.pos === "NOUN" && word.token.features?.["NounType"] !== "Dependent" ? "suffix" : "bound";
@@ -176,17 +206,24 @@ type Skips = {
   readonly skip: ReadonlySet<string>;
   readonly idioms: ReadonlySet<string>;
   readonly conjunctions: ReadonlySet<string>;
+  readonly judging: ReadonlySet<string>;
+  readonly comparative: ReadonlySet<string>;
   readonly wholeWords: ReadonlyMap<string, string>;
   readonly phraseSuffixes: ReadonlySet<string>;
   /** The document's nouns, as documentNounKeys keys them. */
   readonly nouns: ReadonlySet<string>;
 };
 
+/** A listed word outside the comparative frame (担当の方に): the kanji there may be the person of the same reading. */
+const isOutsideComparative = ({ token, following }: InContext, comparative: ReadonlySet<string>): boolean =>
+  comparative.has(token.lemma ?? "") && !COMPARATIVE_PARTICLES.has(following?.[0]?.surface ?? "");
+
 const readingKeyOf = (word: InContext, skips: Skips): string | undefined => {
   const { skip } = skips;
   const { token } = word;
   const lemma = token.lemma;
   if (!CONTENT.has(token.pos) || token.reading === undefined || lemma === undefined || !JAPANESE_WORD.test(lemma) || skip.has(lemma)) return undefined;
+  if (isOutsideComparative(word, skips.comparative)) return undefined;
   const reading = lemmaReading(token.surface, lemma, token.reading);
   if (reading === undefined || [...reading].length < MIN_READING || skip.has(reading) || isCutFromKatakana(word) || isCopulaReadAsVerb(word)) return undefined;
   return `${token.pos}|${useOf(word, skips)}|${reading}`;
@@ -376,6 +413,8 @@ export const orthographicVariant: Detector = (doc, options): Finding[] => {
     skip: new Set([...patternsOf(doc, DISTINCT, options.genre), ...patternsOf(doc, FUKUSHI, options.genre)]),
     idioms: new Set(patternsOf(doc, IDIOM, options.genre)),
     conjunctions: new Set(patternsOf(doc, CONJUNCTION, options.genre)),
+    judging: new Set(patternsOf(doc, JUDGING, options.genre)),
+    comparative: new Set(patternsOf(doc, COMPARATIVE, options.genre)),
     wholeWords: new Map((doc.lexicons[WHOLE_WORD] ?? []).map((entry) => [entry.pattern, entry.group ?? entry.pattern])),
     phraseSuffixes,
     nouns: documentNounKeys(

package/src/detectors/orthography.ts

@@ -8,7 +8,7 @@ import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStart
 import { isSpacedLocationPart, type FloorWords } from "../location-part.ts";
 import { isFieldSeparator, isNameSeparator, type OrganizationWords } from "../name-separator.ts";
 import { addressSpans, clockTimeSpans, identifierSpans, isInsideSpan } from "../spacing-code.ts";
-import { isBoundSuffix, isJoinerSpace } from "../latin-word-boundary.ts";
+import { followsHandle, isBoundSuffix, isJoinerSpace } from "../latin-word-boundary.ts";
 
 /** 書いた形の出現に、動詞の活用した形（行う → 行います）を足したもの。同じ位置は一度だけ。 */
 const avoidedStarts = (sentence: Sentence, entry: LexiconEntry, use: string): number[] => {
@@ -104,8 +104,12 @@ type SentenceCodes = {
  * 「本社 5階」のように名前の後ろに空白で区切った階・部屋の番号の前の空白も、所在の組の区切りなので数えない（location-part.ts）。
  * 「経営企画部 IR担当」のように名前だけを並べた行で、名前と名前を分ける空白も、「所属：経済学科 1年」のように項目の値の組を分ける空白も数えない（name-separator.ts）。
  */
+/** 項目の番号・識別子・チャンネルや宛先の名前（#pj_oss-team）の端の境目。どれも名前や番号を閉じる空白で、空け方の好みではない。 */
+const closesName = (sentence: Sentence, boundary: Boundary, context: NumberContext, codes: SentenceCodes): boolean =>
+  followsItemNumber(sentence.text, boundary, context.itemNumbers) || besideSpan(codes.identifiers, boundary) || followsHandle(sentence.text, boundary);
+
 const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, codes: SentenceCodes): boolean => {
-  if (followsItemNumber(sentence.text, boundary, context.itemNumbers) || besideSpan(codes.identifiers, boundary)) return false;
+  if (closesName(sentence, boundary, context, codes)) return false;
   if (boundary.kind !== "after-digit" && endsWithDivisionLabel(sentence.text.slice(0, boundary.offset), context.divisions)) return false;
   if (boundary.kind === "letter")
     return (

package/src/detectors/oxford-comma.ts

@@ -26,7 +26,7 @@ import {
   shapeOf,
 } from "./list-item.ts";
 import { listReader, type ItemList } from "./list-items.ts";
-import { APPOSITIVE_ANCHOR, isListConjunction, listSentenceOf, VERBAL, type ItemScope, type ListWords } from "./list-sentence.ts";
+import { APPOSITIVE_ANCHOR, isListConjunction, listSentenceOf, NOMINAL, VERBAL, type ItemScope, type ListWords } from "./list-sentence.ts";
 import {
   after,
   contentOnlyWith,
@@ -42,10 +42,12 @@ import {
   some,
   wholeList,
   withoutFirst,
+  type Member,
   type View,
 } from "./list-view.ts";
 import { lowerBound, type TokenRange } from "./token-column.ts";
 import { followsPostcode } from "./postcode-end.ts";
+import { dashBreaks } from "./dash-break.ts";
 
 const EMPTY: TokenRange = { start: 0, end: 0 };
 
@@ -109,6 +111,31 @@ const afterClosedList = (view: View): View => {
   return hasContent(scope, rest) ? { ...after(view, closing), pre: rest } : withoutLead(after(view, closing));
 };
 
+const opensAsNoun = (scope: ItemScope, item: TokenRange): boolean => {
+  const opening = openingOf(scope, item);
+  return opening !== undefined && (opening.pos === "DET" || NOMINAL.has(opening.pos));
+};
+
+const opensAsPredicate = (scope: ItemScope, item: TokenRange): boolean => {
+  const opening = openingOf(scope, item);
+  return opening !== undefined && VERBAL.has(opening.pos) && !isParticiple(opening);
+};
+
+/**
+ * 読点で挟んだ例の句が主語と述語のあいだにある形（Any services not listed above, such as connected services, are excluded and
+ * are not authorized）。句は読点の直後から始まり、例は名詞の句で、句の後ろの項目は動詞で始まる。主語も句も並びの項目ではなく、
+ * 並びがあるなら句の後ろから（are excluded and are not authorized は 2 つ）。例の中の分詞（connected）は名詞にかかる語で、
+ * 述語と同じ形と読まない。句の前は並びの最初の項目で、名詞の句（主語）。動詞で始まれば述語の並びの項目
+ * （Review backups, such as daily snapshots, update indexes and archive logs は 3 つ）。
+ */
+const isAsideBeforePredicate = (view: View, phrase: Member, examples: TokenRange): boolean => {
+  const { scope } = view.list;
+  const [subject, next] = [firstOf(view), firstOf(after(view, phrase))];
+  if (subject === undefined || next === undefined || subject.j !== phrase.j - 1) return false;
+  const opensPhrase = (scope.sentence.exampleEnds[phrase.item.start]?.length ?? 0) > 0;
+  return opensPhrase && opensAsNoun(scope, subject.item) && opensAsNoun(scope, examples) && opensAsPredicate(scope, next.item);
+};
+
 /**
  * 例の句（such as / including / e.g.）のあとが並び。句の前の項目は並びではない（the screen lock on your phone, such as a PIN or
  * phone-based fingerprint は 2 つ）。句の中の項目の形が揃わなければ句で切らない（materials such as green steel, utilizing ..., and
@@ -121,7 +148,9 @@ const fromExample = (view: View): View => {
   const { scope } = view.list;
   const examples = { start: exampleEnd(scope, phrase.item), end: phrase.item.end };
   if (hasListConjunction(scope, examples)) return view;
-  const inPhrase = contentOnlyWith(after(view, phrase), examples);
+  const rest = after(view, phrase);
+  if (isAsideBeforePredicate(view, phrase, examples)) return rest;
+  const inPhrase = contentOnlyWith(rest, examples);
   return sameShapes(inPhrase) ? inPhrase : view;
 };
 
@@ -288,10 +317,13 @@ export const listVerdicts = (tokens: readonly Token[], words: ListWords, source:
   if (!tokens.some(isJudgedConjunction)) return [];
   const sentence = listSentenceOf(tokens, words, source);
   const readItems = listReader(sentence);
+  const breaks = dashBreaks(tokens, source);
   return tokens.flatMap((token, at) => {
     if (!isJudgedConjunction(token, at)) return [];
     // 郵便番号で終わる住所のあとの and / or は、住所の行を区切る読点のあと。並びの読点ではない。
-    return [sentence.inCitedTitle(at) || followsPostcode(source, token.span.start) ? undefined : listAt(readItems(at), at)];
+    // 最後の読点のあとに前後を空けたダッシュがあれば（Washington, DC – The …）、読点はダッシュの前で閉じた日付行や見出しのもの。
+    const notList = sentence.inCitedTitle(at) || followsPostcode(source, token.span.start) || breaks[at] === true;
+    return [notList ? undefined : listAt(readItems(at), at)];
   });
 };
 

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/requirement-smell.ts

@@ -1,4 +1,5 @@
 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";
@@ -64,9 +65,12 @@ const boundedInTime = (doc: ProseDocument, sentence: Sentence, entry: LexiconEnt
     (doc.lexicons[CONCRETE_DEADLINE] ?? []).map((limit) => limit.pattern),
   );
 
-/** A lexicon's words; 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): LexiconEntry[] =>
-  (doc.lexicons[lexicon] ?? []).filter((entry) => !isClassCue(entry) && !isScopeCue(entry));
+/**
+ * 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
@@ -96,9 +100,9 @@ const glossesConditionAt = (doc: ProseDocument, sentence: Sentence, lexicon: str
   );
 
 /** 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 }) =>
-    smellWords(doc, lexicon)
+    smellWords(doc, lexicon, genre)
       .flatMap((entry) => {
         const offset = smellAt(doc, sentence, entry, lexicon, names);
         const examples = offset !== undefined && (answersQuestion(doc, sentence, entry, lexicon, offset) || glossesConditionAt(doc, sentence, lexicon, offset));
@@ -107,12 +111,12 @@ const smellsIn = (doc: ProseDocument, sentence: Sentence, names: () => OpenEndNa
       .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, smellWords(doc, 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/sentence-counts.ts

@@ -69,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[] => {
@@ -81,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-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/signals.ts

@@ -8,7 +8,8 @@ import { abbreviates, expansionAt, termEntryAcronyms, type DefinitionWords, type
 import { isExplained } from "./acronym-compound.ts";
 import { statedAcronyms } from "./acronym-definition.ts";
 import { isBracketed, isInHeading, isNamePart } from "./acronym-lone.ts";
-import { linkTitleSpans } from "./acronym-link.ts";
+import { linkedListTerms, linkTitleSpans } from "./acronym-link.ts";
+import { caseVariantsIn, spelledOutAcronyms } from "./acronym-mention.ts";
 import { conjugatedForms } from "./conjugated-form.ts";
 import { evidenceSpans, hasNumeral, isClaim, isLabelOnly, startsWithin, type AdviceWords } from "./concrete-evidence.ts";
 import { letteredIndexEntries } from "./lettered-index.ts";
@@ -325,10 +326,24 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   ]);
   const expandedAt = expansionAt(definitionWordsOf(doc));
   const stated = statedAcronyms(doc.source, { statements: patternsOf(doc, "definition-statement"), markers: patternsOf(doc, "definition-marker") });
-  const entries = new Set([...termEntryAcronyms(doc.source), ...stated]);
+  // 一覧の語のすぐ下でその語を名指すリンク（- GPL / [GNU General Public License …](…)）と、略語を話題にして書き出した文
+  // （the abbreviation DOB … date of birth）も、略語の説明と読む。
+  const spelled = spelledOutAcronyms(
+    doc.sentences.map((sentence) => sentence.text),
+    patternsOf(doc, "abbreviation-mention"),
+  );
+  const entries = new Set([...termEntryAcronyms(doc.source), ...stated, ...linkedListTerms(doc.source), ...spelled]);
   const headings = doc.sections.map((section) => section.heading);
-  const explainedAlone = (word: string): boolean =>
+  const explainedAsWritten = (word: string): boolean =>
     common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt) || headings.some((heading) => expandsInHeading(heading, word, expandedAt));
+  // 大文字の違うだけの書き方（TCoP と TCOP）は同じ略語と読む。どちらかで説明してあれば説明済み。
+  const written = [body, ...headings].join("\n");
+  const explained = new Map<string, boolean>();
+  const explainedAlone = (word: string): boolean => {
+    const known = explained.get(word) ?? (explainedAsWritten(word) || caseVariantsIn(written, word).some(explainedAsWritten));
+    explained.set(word, known);
+    return known;
+  };
   const counted = outsideSpans(acronymsOf(doc, notationOf(doc)), [
     ...referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")),
     ...outlineLabelSpans(doc.source, patternsOf(doc, "numbered-division")),

package/src/detectors/superlative-name.ts

@@ -31,3 +31,13 @@ export const namesQuantity = (tokens: readonly Token[], range: TokenRange, quant
   const last = single ? lastJoined(tokens, range.end) : undefined;
   return last !== undefined && measures(last, quantities);
 };
+
+/**
+ * 最上級の名詞に空白を挟まず接尾辞が付いて、別の語になっているか（最大化・最大化する）。「最大にする」という動詞で、
+ * 何かが一番だという主張ではない。接尾辞は言語パッケージの語彙表が持つ。
+ */
+export const makesWord = (tokens: readonly Token[], range: TokenRange, suffixes: Lexicon): boolean => {
+  const last = tokens[range.end - 1];
+  const next = tokens[range.end];
+  return last !== undefined && next !== undefined && last.span.end === next.span.start && suffixes.some((entry) => entry.pattern === next.surface);
+};

package/src/detectors/token-shape.ts

@@ -3,6 +3,7 @@ import { isWithinAny, quotedIn } from "../quoted-span.ts";
 import { chronologyRows } from "../chronology-rows.ts";
 import { externalLinkTitleSpans } from "../link-title.ts";
 import type { Detector, Finding, Span, Token } from "../plugin.ts";
+import { countedTokens, uncountedWordsOf } from "../uncounted-particles.ts";
 
 /**
  * 文末が名詞で終わる（体言止め）。箇条書きでは普通だが、本文では文が途中で切れて読める。
@@ -82,8 +83,9 @@ export const doubledParticle: Detector = (doc, options): Finding[] => {
   const nesting = (options.lexicon ?? []).map((entry) => entry.pattern);
   const titles = externalLinkTitleSpans(doc.source, doc.links);
   const breaks = (doc.lexicons[RUN_BREAK_LEXICON] ?? []).map((entry) => entry.pattern);
+  const numbering = uncountedWordsOf(doc.lexicons, nesting);
   return doc.sentences.flatMap((sentence) =>
-    runsOf(sentence.tokens ?? [], nesting, breaks, [...quotedIn(sentence), ...titles])
+    runsOf(countedTokens(sentence.tokens ?? [], numbering), nesting, breaks, [...quotedIn(sentence), ...titles])
       .filter((run) => run.tokens.length > options.limit)
       .map((run) => ({
         rule: "no-doubled-joshi",

package/src/detectors/undefined-term.ts

@@ -81,6 +81,12 @@ export const undefinedTerms = (source: string, sentences: readonly (readonly Tok
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
+/** The words of one group of a lexicon; undefined: the entries with no group. */
+const groupOf = (doc: ProseDocument, lexicon: string, group: string | undefined): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const ATTACHED = "attached-document-cue";
+
 const findingOf = (doc: ProseDocument, use: UndefinedTerm): Finding => ({
   rule: "undefined-term",
   severity: "info",
@@ -107,6 +113,8 @@ const capitalisedUses = (doc: ProseDocument, sentences: readonly (readonly Token
     definedElsewhere: patternsOf(doc, "defined-elsewhere"),
     capacityMarkers: patternsOf(doc, "capacity-marker"),
     articles: patternsOf(doc, "article"),
+    attachedCues: groupOf(doc, ATTACHED, undefined),
+    attachedTitleEnds: groupOf(doc, ATTACHED, "title-end"),
   };
   const marked = [...(doc.markup?.headings ?? []), ...doc.links, ...setApartSpans(doc.source)];
   return capitalisedTerms({ source: doc.source, readable: readableText(doc.source), sentences, defined, named: namedWords(doc.source), marked, words });

package/src/detectors/unknown-word.ts

@@ -13,7 +13,7 @@ const MAX_LENGTH = 30;
 const patternsOf = (doc: ProseDocument, name: string): string[] => (doc.lexicons[name] ?? []).map((entry) => entry.pattern.toLowerCase());
 
 /** 辞書と、語彙表 extra-word の語と、チームの names と、別の rule が言う誤り（known-misspelling）を足した語。 */
-const spellerOf = (doc: ProseDocument, dictionary: ReadonlySet<string>): Speller => ({
+export const spellerOf = (doc: ProseDocument, dictionary: ReadonlySet<string>): Speller => ({
   words: [dictionary, new Set([...patternsOf(doc, "extra-word"), ...(doc.names ?? []).map((name) => name.toLowerCase())])],
   suffixes: (doc.lexicons["word-suffix"] ?? []).map((entry) => ({ suffix: entry.pattern, replacement: entry.instead_of ?? "" })),
   prefixes: patternsOf(doc, "word-prefix"),