chaffjs 0.35.0 → 0.36.0

package/src/detectors/orthographic-variant.ts

@@ -1,17 +1,22 @@
-import type { Detector, Finding, ProseDocument, Sentence, TableCell, Token } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, Span, TableCell, Token } from "../plugin.ts";
+import { externalLinkTitleSpans } from "../link-title.ts";
 import { groupBy, oddSpellings, type KeyedWord, type OddSpelling } from "../spelling-variants.ts";
 import { dropsOkurigana, kanjiKeyAmong, katakanaKey, lemmaReading } from "../kana-spelling.ts";
 import { isKatakanaWord, stemOf } from "../long-vowel.ts";
+import { withNounsAfterParticles } from "../nominal-stem.ts";
 import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
 import { furiganaSpans } from "../furigana.ts";
+import { withCutNounsJoined } from "../split-noun.ts";
+import { japaneseCompanyNameSpans } from "../company-name-run.ts";
 import { acronymsIn, isCapitalsNotSpelling } from "../capitals-with-small.ts";
 import { isPartOfAddress } from "./address-word.ts";
 import { isInCapitalsPassage } from "../capitals-passage.ts";
 import { withoutCoinedNames } from "../coined-hyphen-name.ts";
 import { wholeWordRuns, type WholeWordRun } from "../whole-word-runs.ts";
 import { entriesForGenre } from "../lexicon-genres.ts";
-import { asNounWhereNominal } from "../nominal-stem.ts";
+import { asNounWhereNominal, documentNounKeys } from "../nominal-stem.ts";
+import { isCompoundHead } from "../compound-head.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
@@ -42,6 +47,8 @@ const DISTINCT = "orthographic-variant-distinct";
 const FUKUSHI = "hiragana-fukushi";
 /** Lexicon: idioms written as noun, particle and verb (気をつける). The verb there is compared apart from the verb on its own. */
 const IDIOM = "orthographic-variant-idiom";
+/** Lexicon: verbs whose て-form opening a sentence before a comma is a conjunction (あわせて、). */
+const CONJUNCTION = "orthographic-variant-conjunction";
 /** 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. */
@@ -51,17 +58,37 @@ const patternsOf = (doc: ProseDocument, id: string, genre: string | undefined):
   entriesForGenre(doc.lexicons[id] ?? [], genre).map((entry) => entry.pattern);
 
 /**
- * Whether a stretch of the sentence is outside a quotation, the team's names and a reading in brackets (HTTP（えいちてぃーてぃーぴー）):
- * the first two keep their own spelling, and a reading is not a spelling at all.
+ * The team's names, the company forms (株式会社, ㈱) a registered company name is written next to, and the links that quote an
+ * outside page's title (link-title.ts), placed in the source.
  */
-const isOpenIn = (sentence: Sentence, names: readonly string[]): IsOpen => {
-  const closed = [...quotedSpans(sentence.text, QUOTATION_MARKS), ...furiganaSpans(sentence.text)];
-  const named = nameSpans(sentence.text, names);
+type Names = { readonly team: readonly string[]; readonly companyForms: readonly string[]; readonly linkTitles: readonly Span[] };
+
+/** Spans placed in the source, placed in a sentence's text instead. */
+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.
+ */
+const isOpenIn = (sentence: Sentence, names: Names): IsOpen => {
+  const closed = [
+    ...quotedSpans(sentence.text, QUOTATION_MARKS),
+    ...furiganaSpans(sentence.text),
+    ...japaneseCompanyNameSpans(sentence.text, names.companyForms),
+    ...inSentence(sentence, names.linkTitles),
+  ];
+  const named = nameSpans(sentence.text, names.team);
   return (start, end) => !isWithinAny(closed, { start, end }) && !touchesAny(named, start, end);
 };
 
-/** A word and the two words before it, in its sentence. */
-type InContext = { readonly token: Token; readonly previous: Token | undefined; readonly before: Token | undefined };
+/** A word, the two words before it and the two after it, in its sentence. */
+type InContext = {
+  readonly token: Token;
+  readonly previous: Token | undefined;
+  readonly before: Token | undefined;
+  readonly following?: readonly Token[];
+};
 
 /** A verb's て-form the tokenizer read as a conjunction (追って at the head of a sentence): a kanji stem and て or で. Connectives (そして, それで) are kana. */
 const TE_FORM_CONJUNCTION = /^\p{Script=Han}.*[てで]$/u;
@@ -99,13 +126,32 @@ const isKanaSuffix = ({ token, previous }: InContext): boolean =>
 const isIdiomVerb = ({ token, previous, before }: InContext, idioms: ReadonlySet<string>): boolean =>
   token.pos === "VERB" && previous?.pos === "ADP" && before !== undefined && idioms.has(`${before.surface}${previous.surface}${token.lemma ?? token.surface}`);
 
+const TE = new Set(["て", "で"]);
+const COMMA = new Set(["、", "，", ","]);
+
+/**
+ * A listed verb's て-form that opens its sentence and is followed by a comma (あわせて、…): a conjunction ("in addition"), which
+ * many guides write in kana while the verb (日程を合わせる) keeps its kanji.
+ */
+const isConjunctionUse = ({ token, previous, following }: InContext, conjunctions: ReadonlySet<string>): boolean =>
+  token.pos === "VERB" &&
+  conjunctions.has(token.lemma ?? "") &&
+  (previous === undefined || previous.pos === "PUNCT") &&
+  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> };
+
 /**
  * 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.
+ * 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.
  */
-const useOf = (word: InContext, idioms: ReadonlySet<string>): string => {
+const useOf = (word: InContext, { idioms, conjunctions }: Uses): string => {
   if (isIdiomVerb(word, idioms)) return "idiom";
+  if (isConjunctionUse(word, conjunctions)) return "conjunction";
   if (isKanaSuffix(word)) return "suffix";
   if (!isHelper(word)) return "free";
   return word.token.pos === "NOUN" && word.token.features?.["NounType"] !== "Dependent" ? "suffix" : "bound";
@@ -129,17 +175,21 @@ const isCopulaReadAsVerb = ({ token, previous }: InContext): boolean =>
 type Skips = {
   readonly skip: ReadonlySet<string>;
   readonly idioms: ReadonlySet<string>;
+  readonly conjunctions: ReadonlySet<string>;
   readonly wholeWords: ReadonlyMap<string, string>;
   readonly phraseSuffixes: ReadonlySet<string>;
+  /** The document's nouns, as documentNounKeys keys them. */
+  readonly nouns: ReadonlySet<string>;
 };
 
-const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefined => {
+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;
   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, idioms)}|${reading}`;
+  return `${token.pos}|${useOf(word, skips)}|${reading}`;
 };
 
 /**
@@ -160,7 +210,7 @@ const wholeWordOf = (
 
 /** Japanese words keyed by part of speech, use and the reading of the dictionary form, spelled as the dictionary form. */
 const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[] => {
-  const tokens = sentence.tokens ?? [];
+  const tokens = withNounsAfterParticles(sentence.tokens ?? []);
   const runs = wholeWordRuns(tokens, skips.wholeWords);
   const inRun = new Set(runs.flatMap(({ first, last }) => Array.from({ length: last - first + 1 }, (_, extra) => first + extra)));
   const whole = runs.flatMap((run) => wholeWordOf(sentence, tokens, run, isOpen, skips.wholeWords));
@@ -169,11 +219,11 @@ const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[
     ...tokens.flatMap((written, at): Placed[] => {
       if (inRun.has(at)) return [];
       const next = tokens[at + 1];
-      const token = asNounWhereNominal(written, next, skips.phraseSuffixes);
-      const key = readingKeyOf({ token, previous: tokens[at - 1], before: tokens[at - 2] }, skips);
+      const token = asNounWhereNominal(written, next, skips.phraseSuffixes, skips.nouns);
+      const key = readingKeyOf({ token, previous: tokens[at - 1], before: tokens[at - 2], following: tokens.slice(at + 1, at + 3) }, skips);
       const local = token.span.start - sentence.span.start;
       if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
-      const compoundHead = token.pos === "NOUN" && next?.pos === "NOUN" && isTouching(token, next) && !skips.phraseSuffixes.has(next.surface);
+      const compoundHead = isCompoundHead(token, tokens, at, skips.phraseSuffixes);
       return [{ key, spelling: token.lemma, sentence, offset: token.span.start, compoundHead }];
     }),
   ];
@@ -300,7 +350,7 @@ const LINK_CHROME = /\]\([^)]*\)|\]\[[^\]]*\]|\[/gu;
 const withoutLinkChrome = (text: string): string => text.replaceAll(LINK_CHROME, (chrome) => " ".repeat(chrome.length));
 
 /** A body cell of a table read as a sentence of its own: the prose covers tables, so a cell's words (片栗粉 in a list of ingredients) are not in the sentences. Header rows stay out. */
-const cellPlace = (cell: TableCell, names: readonly string[]): Place => {
+const cellPlace = (cell: TableCell, names: Names): Place => {
   const text = withoutLinkChrome(cell.text);
   const sentence: Sentence = { span: { start: cell.start, end: cell.end }, text, tokens: cell.tokens ?? [] };
   return { sentence, isOpen: isOpenIn(sentence, names), readsLatin: !DATA_KEY_CELL.test(text.trim()) };
@@ -312,18 +362,28 @@ const cellPlace = (cell: TableCell, names: readonly string[]): Place => {
  * document writes less is pointed at. No way is called right; limit is the largest share, in percent, the minority may have.
  */
 export const orthographicVariant: Detector = (doc, options): Finding[] => {
-  const skips: Skips = {
-    skip: new Set([...patternsOf(doc, DISTINCT, options.genre), ...patternsOf(doc, FUKUSHI, options.genre)]),
-    idioms: new Set(patternsOf(doc, IDIOM, options.genre)),
-    wholeWords: new Map((doc.lexicons[WHOLE_WORD] ?? []).map((entry) => [entry.pattern, entry.group ?? entry.pattern])),
-    phraseSuffixes: new Set(patternsOf(doc, PHRASE_SUFFIX, options.genre)),
+  const names: Names = {
+    team: doc.names ?? [],
+    companyForms: (doc.lexicons["company-form"] ?? []).map((entry) => entry.pattern),
+    linkTitles: externalLinkTitleSpans(doc.source, doc.links),
   };
-  const names = doc.names ?? [];
   const placed: Place[] = [
     ...doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, names), readsLatin: true })),
     ...(doc.tableCells?.() ?? []).map((cell) => cellPlace(cell, names)),
   ];
-  const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skips)));
+  const phraseSuffixes = new Set(patternsOf(doc, PHRASE_SUFFIX, options.genre));
+  const skips: Skips = {
+    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)),
+    wholeWords: new Map((doc.lexicons[WHOLE_WORD] ?? []).map((entry) => [entry.pattern, entry.group ?? entry.pattern])),
+    phraseSuffixes,
+    nouns: documentNounKeys(
+      placed.map(({ sentence }) => sentence.tokens ?? []),
+      phraseSuffixes,
+    ),
+  };
+  const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(withCutNounsJoined(sentence, skips.nouns), isOpen, skips)));
   const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
   const runs = placed.flatMap(({ sentence, isOpen }) => katakanaRunWords(sentence, isOpen));
   const dictionary = doc.dictionary?.();

package/src/detectors/orthography.ts

@@ -8,6 +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";
 
 /** 書いた形の出現に、動詞の活用した形（行う → 行います）を足したもの。同じ位置は一度だけ。 */
 const avoidedStarts = (sentence: Sentence, entry: LexiconEntry, use: string): number[] => {
@@ -55,6 +56,8 @@ type NumberContext = NameContext & {
   readonly itemNumbers: ReadonlySet<string>;
   readonly floors: FloorWords;
   readonly organizations: OrganizationWords;
+  /** 日本語の句をつなぐ英語の語（or、vs.）と、英字の語に付ける接尾の語（版、化）。 */
+  readonly latinWords: { readonly joiners: ReadonlySet<string>; readonly boundSuffixes: ReadonlySet<string> };
 };
 
 /** 文頭の項目の番号の後ろと見る境目の位置の上限。番号は短く文の頭にあるので、これより後ろの境目は番号の後ろではない。長い文で文頭からの切り出しを繰り返さない。 */
@@ -105,7 +108,12 @@ const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContex
   if (followsItemNumber(sentence.text, boundary, context.itemNumbers) || besideSpan(codes.identifiers, boundary)) return false;
   if (boundary.kind !== "after-digit" && endsWithDivisionLabel(sentence.text.slice(0, boundary.offset), context.divisions)) return false;
   if (boundary.kind === "letter")
-    return !besideSpan(codes.addresses, boundary) && !isNameSeparator(sentence.text, boundary, sentence.tokens, sentence.span.start, context.organizations);
+    return (
+      !besideSpan(codes.addresses, boundary) &&
+      !isNameSeparator(sentence.text, boundary, sentence.tokens, sentence.span.start, context.organizations) &&
+      !isJoinerSpace(sentence.text, boundary, context.latinWords.joiners) &&
+      !isBoundSuffix(sentence.text, boundary, sentence.tokens, sentence.span.start, context.latinWords.boundSuffixes)
+    );
   if (isInsideSpan(codes.clockTimes, digitBeside(boundary))) return false;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
   if (run === undefined) return true;
@@ -180,6 +188,7 @@ export const latinSpacing: Detector = (doc, options): Finding[] => {
     itemNumbers: numberedItems(patternList(doc, "item-number"), doc.prose ?? doc.source),
     floors: { units: patternsOf(doc, "floor-unit"), levels: patternsOf(doc, "floor-level") },
     organizations: { units: patternsOf(doc, "organization-unit"), forms: patternList(doc, "company-form") },
+    latinWords: { joiners: patternsOf(doc, "latin-joiner"), boundSuffixes: patternsOf(doc, "latin-bound-suffix") },
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);

package/src/detectors/oxford-comma.ts

@@ -45,6 +45,7 @@ import {
   type View,
 } from "./list-view.ts";
 import { lowerBound, type TokenRange } from "./token-column.ts";
+import { followsPostcode } from "./postcode-end.ts";
 
 const EMPTY: TokenRange = { start: 0, end: 0 };
 
@@ -55,10 +56,35 @@ const commaBefore = (scope: ItemScope, at: number): boolean => scope.sentence.to
  * 節の最初の項目が前置詞・接続詞・副詞・to・過去分詞で始まり、次の項目と頭の形が違えば外す。
  * Quickly, quietly and carefully は残る。For managers, engineers and designers, も外れるが、前置詞のあとの名詞を
  * 項目と読むと、Over this period, the subcommittees and the full committee ... を並びと誤る。こちらのほうが多い。
+ * 順番の語（First,）のあとにもう一つ導入の句が続く（First, outside a block, …）ときは、順番の語を外してから確かめる。
  */
 const LEAD_POS = new Set(["ADP", "SCONJ", "ADV", "PART"]);
 
+const isSequenceWord = (scope: ItemScope, token: Token | undefined): boolean => scope.sentence.words.sequence?.has(token?.surface.toLowerCase() ?? "") ?? false;
+
+const SENTENCE_MARKS = new Set(["PUNCT", "SYM"]);
+
+/**
+ * 順番の語と読点（First, / Next,）で始まる最初の項目から、その語を外した並び。解析器は First を形容詞と読み、読点で項目を切らないことがある。
+ * 文頭の語だけ。文の途中の first は項目のことがある（We support first, fallback, and legacy modes）。
+ * 次の項目も順番の語なら、順番の語の並び（first, second and third）なので外さない。
+ */
+const withoutSequenceWord = (view: View): View | undefined => {
+  const { scope } = view.list;
+  const [first, second] = [firstOf(view), secondOf(view)];
+  if (first === undefined || second === undefined) return undefined;
+  const at = firstAt(scope, "open", first.item);
+  const { tokens } = scope.sentence;
+  const opensSentence = tokens.slice(0, at).every((token) => SENTENCE_MARKS.has(token.pos));
+  if (!opensSentence || !isSequenceWord(scope, tokens[at]) || tokens[at + 1]?.surface !== "," || isSequenceWord(scope, openingOf(scope, second.item)))
+    return undefined;
+  const rest = { start: at + 2, end: first.item.end };
+  return hasContent(scope, rest) ? { ...withoutFirst(view), pre: rest } : withoutFirst(view);
+};
+
 const withoutLead = (view: View): View => {
+  const afterSequence = withoutSequenceWord(view);
+  if (afterSequence !== undefined) return withoutLead(afterSequence);
   const { scope } = view.list;
   const [first, second] = [firstOf(view), secondOf(view)];
   const opening = first === undefined ? undefined : openingOf(scope, first.item);
@@ -225,6 +251,15 @@ const itemsAgree = (scope: ItemScope, view: View, afterItem: TokenRange, shape:
   return clausesAgree && (!VERBAL.has(shape) || every(view, "hasVerb"));
 };
 
+/** 否定で始まる項目（not cleaner）。 */
+const CONTRAST = new Set(["not", "never"]);
+
+/**
+ * and / or の前の項目が否定で始まれば、読点の前と対比している（more correct, not cleaner or more elegant）。
+ * and / or が結ぶのは否定の中の 2 つで、読点の前の項目と並ぶ 3 つではない。
+ */
+const opensContrast = (scope: ItemScope, item: TokenRange): boolean => CONTRAST.has(openingOf(scope, item)?.surface.toLowerCase() ?? "");
+
 /**
  * 読点で区切った項目が and / or の前に 2 つ以上あり、最後の項目と and の後ろが同じ形のときだけ並列。
  * 導入の読点（After the review, the team fixed the bug and shipped it.）や、節をつなぐ読点
@@ -237,6 +272,7 @@ const listAt = (list: ItemList, at: number): boolean | undefined => {
   const items = fromParticiplePhrase(fromExample(afterClosedList(withoutLead(wholeList(list)))), afterItem);
   if (listContinues(scope, afterItem) || isAppositive(scope, at, items, afterItem) || insideLastItem(scope, at, items, afterItem)) return undefined;
   const last = lastOf(items);
+  if (last !== undefined && opensContrast(scope, last.item)) return undefined;
   const shape = last === undefined ? undefined : shapeOf(scope, last.item);
   if (sizeOf(items) < 2 || shape === undefined || shape !== shapeOf(scope, afterItem)) return undefined;
   return itemsAgree(scope, items, afterItem, shape) ? commaBefore(scope, at) : undefined;
@@ -254,7 +290,8 @@ export const listVerdicts = (tokens: readonly Token[], words: ListWords, source:
   const readItems = listReader(sentence);
   return tokens.flatMap((token, at) => {
     if (!isJudgedConjunction(token, at)) return [];
-    return [sentence.inCitedTitle(at) ? undefined : listAt(readItems(at), at)];
+    // 郵便番号で終わる住所のあとの and / or は、住所の行を区切る読点のあと。並びの読点ではない。
+    return [sentence.inCitedTitle(at) || followsPostcode(source, token.span.start) ? undefined : listAt(readItems(at), at)];
   });
 };
 
@@ -275,6 +312,8 @@ export const oxfordComma: Detector = (doc, options): Finding[] => {
     example: doc.lexicons["example-marker"] ?? [],
     pair: patternsOf(doc.lexicons["pair-opener"]),
     region: doc.lexicons["place-region"] ?? [],
+    titleCue: (doc.lexicons["title-cue"] ?? []).map((entry) => entry.pattern),
+    sequence: patternsOf(doc.lexicons["sequence-opener"]),
   };
   const judged = doc.sentences.flatMap((sentence) => {
     const oxford = oxfordIn(sentence.tokens ?? [], words, doc.source);

package/src/detectors/person-consistency.ts

@@ -1,5 +1,5 @@
 import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
-import { personMentions, personMinorities, type PersonMention, type PersonWords } from "../person-forms.ts";
+import { personMentions, personMinorities, withoutOtherSenses, type PersonMention, type PersonWords } from "../person-forms.ts";
 
 const wordsOf = (doc: ProseDocument, words: PersonWords["words"]): PersonWords => ({
   words,
@@ -9,14 +9,16 @@ const wordsOf = (doc: ProseDocument, words: PersonWords["words"]): PersonWords =
 
 /**
  * One document naming itself (私たち / 弊社, 私 / 筆者) or its reader (you / one) two ways: the minority form of each slot.
- * Sentences in another language than the document's are left out; quotations are left out by personMentions.
+ * Sentences in another language than the document's are left out; quotations are left out by personMentions. A form the
+ * language package lists in person-other-sense (本社, also the head office) counts only where it is the usual form.
  */
 export const personMix: Detector = (doc, options): Finding[] => {
   const person = wordsOf(doc, options.lexicon ?? []);
   const entries: { readonly sentence: Sentence; readonly mention: PersonMention }[] = doc.sentences
     .filter((sentence) => sentence.embeddedLanguage === undefined)
     .flatMap((sentence) => personMentions(sentence.text, person).map((mention) => ({ sentence, mention })));
-  return personMinorities(entries, options.limit).flatMap(({ odd, usual, of }) =>
+  const otherSenses = new Set((doc.lexicons["person-other-sense"] ?? []).map((entry) => entry.pattern));
+  return personMinorities(withoutOtherSenses(entries, otherSenses), options.limit).flatMap(({ odd, usual, of }) =>
     odd.map(({ sentence, mention }) => ({
       rule: "",
       severity: "info" as const,

package/src/detectors/phrase-match.ts

@@ -1,5 +1,6 @@
-import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
 import { entryEnds, entryIn } from "./lexicon-match.ts";
+import { mentionCuesOf, onlyMentioned } from "./mentioned-phrase.ts";
 import { closingSentences } from "../closing-paragraph.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
@@ -17,9 +18,12 @@ const inScope = (doc: ProseDocument, where: string | undefined): readonly Senten
 
 type Hit = { readonly sentence: Sentence; readonly matched: string };
 
-const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
+/** Whether the entry's words in the sentence count as a use. phrase-match counts every one. */
+type IsUsed = (sentence: Sentence, entry: LexiconEntry) => boolean;
+
+const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon, isUsed: IsUsed = () => true): Hit[] =>
   sentences.flatMap((sentence) => {
-    const matched = lexicon.find((entry) => entryIn(sentence, entry));
+    const matched = lexicon.find((entry) => entryIn(sentence, entry) && isUsed(sentence, entry));
     return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
@@ -33,9 +37,9 @@ const findingsOf = (hits: readonly Hit[], limit: number, count = hits.length): F
     values: { matched: hit.matched, count, limit, offset: hit.sentence.span.start },
   }));
 
-const phraseHits = (doc: ProseDocument, options: DetectorOptions): Hit[] => {
+const phraseHits = (doc: ProseDocument, options: DetectorOptions, isUsed?: IsUsed): Hit[] => {
   const lexicon = options.lexicon ?? [];
-  return lexicon.length === 0 ? [] : hitsIn(inScope(doc, options.where), lexicon);
+  return lexicon.length === 0 ? [] : hitsIn(inScope(doc, options.where), lexicon, isUsed);
 };
 
 /**
@@ -47,6 +51,13 @@ export const phraseMatch: Detector = (doc, options): Finding[] => {
   return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
 };
 
+/** phrase-match の、言葉として名指しただけの言い回し（the phrase "…", 「…」という言い方）を数えない版（mentioned-phrase.ts）。 */
+export const phraseInUse: Detector = (doc, options): Finding[] => {
+  const cues = mentionCuesOf(doc.lexicons["mention-cue"] ?? []);
+  const hits = phraseHits(doc, options, (sentence, entry) => !onlyMentioned(sentence, entry, cues));
+  return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
+};
+
 type Uses = { readonly sentence: Sentence; readonly matched: string; readonly count: number };
 
 /**

package/src/detectors/placeholder-text.ts

@@ -29,6 +29,7 @@ const withoutClosers = (text: string): string => {
 /** Lexicon groups of placeholder-word. An entry without a group is a word written inside a template's brackets. */
 const MARKER = "marker";
 const INSTRUCTION = "instruction";
+const LABEL = "label";
 
 const innerOf = (match: RegExpExecArray): string => (match[1] ?? match[2] ?? match[3] ?? "").trim().toLowerCase();
 
@@ -64,11 +65,24 @@ const markerSpans = (text: string, markers: Lexicon): Span[] => {
   return [{ start, end: start + withoutClosers(rest).length }];
 };
 
+/**
+ * A template's instruction label left in the text ("OPTIONAL: General conclusions"): the label exactly as the lexicon
+ * writes it, in capitals, opening the line before a colon and some text. "Optional: bring a jacket" is a note, not a label.
+ */
+const labelSpans = (line: string, labels: Lexicon): Span[] => {
+  const start = OPENING.exec(line)?.[0].length ?? 0;
+  const rest = line.slice(start);
+  const label = labels.find((entry) => rest.startsWith(entry.pattern));
+  if (label === undefined) return [];
+  const after = rest.slice(label.pattern.length);
+  return COLON_NEXT.test(after) && withoutClosers(after.replace(COLON_NEXT, "")) !== "" ? [{ start, end: start + rest.trimEnd().length }] : [];
+};
+
 /** Each line of a sentence on its own: values a line apart ("TBD: owner" then "TBD: date") are two blanks, not one. */
-const lineMarkerSpans = (text: string, markers: Lexicon): Span[] =>
+const lineMarkerSpans = (text: string, markers: Lexicon, labels: Lexicon): Span[] =>
   text.split("\n").flatMap((line, index, lines) => {
     const offset = lines.slice(0, index).reduce((sum, previous) => sum + previous.length + 1, 0);
-    return markerSpans(line, markers).map((span) => ({ start: span.start + offset, end: span.end + offset }));
+    return [...markerSpans(line, markers), ...labelSpans(line, labels)].map((span) => ({ start: span.start + offset, end: span.end + offset }));
   });
 
 /** 文の中の、埋め忘れた雛形の空欄（[Your Name]、【会社名】、（ここに会社名を書く）、TBD: …）の範囲。words は placeholder-word の語彙表。 */
@@ -76,9 +90,10 @@ export const placeholderSpans = (text: string, words: Lexicon): Span[] => {
   const bracketWords = words.filter((word) => word.group === undefined);
   const instructions = words.filter((word) => word.group === INSTRUCTION);
   const markers = words.filter((word) => word.group === MARKER);
+  const labels = words.filter((word) => word.group === LABEL);
   return [
     ...bracketedSpans(text, BRACKETED, (inner) => holdsWord(inner, bracketWords)),
     ...(instructions.length === 0 ? [] : bracketedSpans(text, PARENTHESIZED, (inner) => opensWith(inner, instructions))),
-    ...lineMarkerSpans(text, markers),
+    ...lineMarkerSpans(text, markers, labels),
   ].toSorted((left, right) => left.start - right.start);
 };

package/src/detectors/placeholder.ts

@@ -5,6 +5,8 @@ import { escapeRegExp } from "../orthography.ts";
  * 定型文の書式で、略語ではない。繰り返しの語が、日付・時刻の単位の語（年、月、日）の前にあるか、
  * 区切り（/、:、-、.）で別の繰り返しの語か数字と繋がっているときだけ認める。単位の語は言語パッケージの語彙表から読む。
  * AI時代の AI や CI/CD の CD は、同じ文字の繰り返しではないので略語のまま数える。
+ * 単位の前には空白 1 つを挟んでもよい（XX 月 XX 日）。ひな形が名前の代わりに書く O か X を 4 つ以上並べた語（OOOO、XXXX）も、
+ * 単位が無くても略語ではない。3 つまで（AAA、XXX）は略語にもあり、ほかの文字の繰り返し（IIII、MMMMM）は崩れたローマ数字にもある。
  */
 
 type Span = { readonly start: number; readonly end: number };
@@ -14,6 +16,7 @@ const PART = String.raw`(?:[A-Z]{2,}|\d+)`;
 const SEPARATOR = "[/／:：.-]";
 const JOINED = new RegExp(String.raw`(?<![A-Za-z0-9_&])${PART}(?:${SEPARATOR}${PART})+(?![A-Za-z0-9_&])`, "gu");
 const CAPITALS = /[A-Z]+/gu;
+const LONG_REPEAT = /(?<![A-Za-z0-9_&])(?<letter>[OX])\k<letter>{3,}(?![A-Za-z0-9_&])/gu;
 
 const isRepeated = (word: string): boolean => REPEATED.test(word);
 
@@ -30,9 +33,13 @@ const joinedSpans = (text: string): Span[] =>
 
 const beforeUnitSpans = (text: string, units: readonly string[]): Span[] => {
   if (units.length === 0) return [];
-  const pattern = new RegExp(String.raw`(?<![A-Za-z0-9_&])[A-Z]{2,}(?=${units.map(escapeRegExp).join("|")})`, "gu");
+  const pattern = new RegExp(String.raw`(?<![A-Za-z0-9_&])[A-Z]{2,}(?= ?(?:${units.map(escapeRegExp).join("|")}))`, "gu");
   return [...text.matchAll(pattern)].filter((match) => isRepeated(match[0])).map(spanOf);
 };
 
-/** 文の中の、日付・時刻の書式に置いた大文字の範囲。units は日付・時刻の単位の語。 */
-export const placeholderSpans = (text: string, units: readonly string[]): Span[] => [...joinedSpans(text), ...beforeUnitSpans(text, units)];
+/** 文の中の、日付・時刻の書式とひな形の名前に置いた大文字の範囲。units は日付・時刻の単位の語。 */
+export const placeholderSpans = (text: string, units: readonly string[]): Span[] => [
+  ...joinedSpans(text),
+  ...beforeUnitSpans(text, units),
+  ...[...text.matchAll(LONG_REPEAT)].map(spanOf),
+];

package/src/detectors/postcode-end.ts

@@ -0,0 +1,16 @@
+// A postal address closed by its postcode right before an and / or ("… Upper Street, Leeds LS1 4AB, or email us"). The
+// commas between the address's lines are the address's, not a list's. Pure.
+
+/** UK (LS1 4AB, TW9 4DU, EC1A 1BB), US state and ZIP (IL 62701, DC 20001-1234), Canada (K1A 0B1). */
+const POSTCODE = String.raw`(?:[A-Z]{1,2}\d[A-Z\d]? \d[A-Z]{2}|[A-Z]{2} \d{5}(?:-\d{4})?|[A-Z]\d[A-Z] \d[A-Z]\d)`;
+/**
+ * The place the postcode is written after: a town (Leeds, Springfield,) or a province's code (ON). A code after a
+ * lower-case word ("model X1 4AB") is a product's, not an address's.
+ */
+const PLACE = String.raw`(?<![\w-])(?:[A-Z][a-z]+|[A-Z]{2}),? `;
+const POSTCODE_BEFORE = new RegExp(String.raw`${PLACE}${POSTCODE},?[ \t]*$`, "u");
+/** How far back the place may start: a long town name, the longest postcode and its comma, with room for spacing. */
+const REACH = 48;
+
+/** Whether the text before offset ends with a place and its postcode, the comma after it allowed. */
+export const followsPostcode = (source: string, offset: number): boolean => POSTCODE_BEFORE.test(source.slice(Math.max(0, offset - REACH), offset));

package/src/detectors/prose-total-words.ts

@@ -0,0 +1,18 @@
+import type { ProseDocument } from "../plugin.ts";
+import type { TotalWords } from "../structure/prose-total.ts";
+
+const patternsOf = (doc: ProseDocument, id: string, group?: string): string[] =>
+  (doc.lexicons[id] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+/** total-mismatch が文の中の合計と内訳を読む語。言語パッケージの語彙表から取る。 */
+export const proseTotalWordsOf = (doc: ProseDocument): TotalWords => ({
+  totals: patternsOf(doc, "total-phrase"),
+  breakdowns: patternsOf(doc, "breakdown-phrase"),
+  discounts: patternsOf(doc, "discount-word"),
+  joiners: patternsOf(doc, "breakdown-gap-joiner"),
+  leads: patternsOf(doc, "total-breakdown-lead"),
+  partials: patternsOf(doc, "breakdown-partial-word"),
+  mainOnly: patternsOf(doc, "breakdown-partial-word", "main"),
+  backReferences: patternsOf(doc, "total-back-reference"),
+  roundedUnits: patternsOf(doc, "rounded-amount-unit"),
+});

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,10 @@
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.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 +13,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,20 +64,45 @@ 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; 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));
+
+/**
+ * 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[] =>
   SMELLS.flatMap(({ lexicon, variant }) =>
-    (doc.lexicons[lexicon] ?? [])
+    smellWords(doc, lexicon)
       .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),
   );
@@ -80,6 +113,6 @@ export const requirementSmell: Detector = (doc): Finding[] => {
   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));
+  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));
 };