chaffjs 0.35.0 → 0.37.0

package/src/detectors/orthographic-variant.ts

@@ -1,17 +1,23 @@
-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";
+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
@@ -42,6 +48,16 @@ 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: 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. */
@@ -51,17 +67,39 @@ 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 (関東珪曹硝子㈱), 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 = [
+    ...quotedSpans(sentence.text, QUOTATION_MARKS),
+    ...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);
 };
 
-/** 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 +137,51 @@ 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 ?? "");
+
+/** と, 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.
+ * 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, and a verb of judging (〜とみられる) a sixth.
  */
-const useOf = (word: InContext, idioms: ReadonlySet<string>): 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";
@@ -129,17 +205,28 @@ const isCopulaReadAsVerb = ({ token, previous }: InContext): boolean =>
 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>;
 };
 
-const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefined => {
+/** 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, idioms)}|${reading}`;
+  return `${token.pos}|${useOf(word, skips)}|${reading}`;
 };
 
 /**
@@ -160,7 +247,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 +256,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 +387,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 +399,30 @@ 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)),
+    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(
+      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 { followsHandle, 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> };
 };
 
 /** 文頭の項目の番号の後ろと見る境目の位置の上限。番号は短く文の頭にあるので、これより後ろの境目は番号の後ろではない。長い文で文頭からの切り出しを繰り返さない。 */
@@ -101,11 +104,20 @@ 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 !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 +192,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

@@ -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,9 +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 };
 
@@ -55,10 +58,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);
@@ -83,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
@@ -95,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;
 };
 
@@ -225,6 +280,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 +301,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;
@@ -252,9 +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 [];
-    return [sentence.inCitedTitle(at) ? undefined : listAt(readItems(at), at)];
+    // 郵便番号で終わる住所のあとの and / or は、住所の行を区切る読点のあと。並びの読点ではない。
+    // 最後の読点のあとに前後を空けたダッシュがあれば（Washington, DC – The …）、読点はダッシュの前で閉じた日付行や見出しのもの。
+    const notList = sentence.inCitedTitle(at) || followsPostcode(source, token.span.start) || breaks[at] === true;
+    return [notList ? undefined : listAt(readItems(at), at)];
   });
 };
 
@@ -275,6 +344,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"),
+});