chaffjs 0.33.0 → 0.35.0

package/src/detectors/name-variant.ts

@@ -1,12 +1,13 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, type NameMention, type VariantChars } from "../name-variants.ts";
+import type { WordUse } from "../name-end-letter.ts";
 import { withKnownNeighbours } from "../name-neighbours.ts";
 import type { SpellingInput } from "../name-spelling-chars.ts";
 import { lookalikeSlipsIn, type LookalikeChars } from "../name-lookalike-chars.ts";
-import { readingOfWords, type CharReadings } from "../name-char-reading.ts";
+import { givenNameReadingOf, readingOfWords, type CharReadings } from "../name-char-reading.ts";
 import { nameCueAt, type NameCues } from "../name-cue.ts";
 import { quoteAt } from "./structure-tree.ts";
-import { companyMentionsIn, companyVariants, type CompanyForm, type IsProper } from "../company-names.ts";
+import { companyMentionsIn, companyVariants, type CompanyForm, type CompanyMention, type IsProper, type PredicateEnds } from "../company-names.ts";
 import { kanaSpelledCompanies, type ReadWord } from "../company-kana-spelling.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { tableBodyCells } from "../facts/table-facts.ts";
@@ -22,6 +23,7 @@ import { spacedPersonNamesIn } from "../spaced-person-name.ts";
 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";
 
 // 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
 // （です、まで）は name-particle、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
@@ -33,6 +35,18 @@ const variantCharsOf = (doc: ProseDocument): VariantChars =>
 const charReadingsOf = (doc: ProseDocument): CharReadings =>
   new Map((doc.lexicons["name-char-reading"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
 
+/**
+ * 名の中での字の読み（建太 の 建 を ケン）は、語彙表 given-name-char-reading が組（group）に言う。解析器が読めない字の読み
+ * （name-char-reading）も名の中で同じに読む。
+ */
+const givenCharReadingsOf = (doc: ProseDocument, chars: CharReadings): CharReadings =>
+  new Map([
+    ...chars,
+    ...(doc.lexicons["given-name-char-reading"] ?? []).flatMap((entry): [string, string][] =>
+      entry.group === undefined ? [] : [[entry.pattern, entry.group]],
+    ),
+  ]);
+
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
 /** 会社の形の語（株式会社、Inc）は語彙表 company-form が、同じ形の組（group）と名前のどちら側に立つか（position）とともに言う。 */
@@ -124,23 +138,30 @@ const kanaStopsOf = (doc: ProseDocument): Parameters<typeof companyMentionsIn>[3
   return { particles: inGroup("particle"), openers: inGroup("opener"), ends: inGroup("end") };
 };
 
+/** 品詞解析が形容詞・動詞・助動詞と読んだ語の終わり。い で終わるひらがな（ながい食品）を会社の名前の頭に入れないため。 */
+const PREDICATE_POS: ReadonlySet<string> = new Set(["ADJ", "VERB", "AUX"]);
+const predicateEndsOf = (doc: ProseDocument): PredicateEnds =>
+  new Set(tokensOf(doc).flatMap((token) => (PREDICATE_POS.has(token.pos) ? [token.span.end] : [])));
+
 const readWordsOf = (doc: ProseDocument): ReadWord[] =>
   tokensOf(doc).map((token) => ({ start: token.span.start, end: token.span.end, surface: token.surface, reading: token.reading }));
 
+/** 会社の名前の現れ。大文字で書いた一節の中のものは除く。 */
+const companyMentionsOf = (doc: ProseDocument, prose: string): CompanyMention[] =>
+  outsideCapitals(prose, companyMentionsIn(prose, [...companyFormsOf(doc), ...foreignFormsOf(doc)], properOf(doc), kanaStopsOf(doc), predicateEndsOf(doc)));
+
 /**
  * 会社の名前の書き分けと、名前の漢字一字をその読みのかなで書いた所（みどり野 と みどりの）。名前の見方がすでに指した所と重なる
  * ものは除く。
  */
-const companyFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] => {
-  const stops = kanaStopsOf(doc);
-  const mentions = companyMentionsIn(prose, [...companyFormsOf(doc), ...foreignFormsOf(doc)], properOf(doc), stops);
+const companyFindings = (doc: ProseDocument, prose: string, mentions: readonly CompanyMention[], reported: readonly Reported[]): Reported[] => {
   const variants = companyVariants(mentions).map(({ mention, usual, kind }) => ({
     offset: mention.offset,
     name: mention.surface,
     usual,
     kind: kind === "spelling" ? kind : `company-${kind}`,
   }));
-  const kana = kanaSpelledCompanies(prose, mentions, readWordsOf(doc), stops.particles)
+  const kana = kanaSpelledCompanies(prose, mentions, readWordsOf(doc), kanaStopsOf(doc).particles)
     .map(({ surface, offset, usual }) => ({ offset, name: surface, usual, kind: "company-kana" }))
     .filter((found) => !overlapsAny(variants, found.offset, found.name.length));
   return [...variants, ...kana].filter(({ offset, name }) => !overlapsAny(reported, offset, name.length));
@@ -189,6 +210,9 @@ const orderWordsOf = (doc: ProseDocument): OrderWord[] => {
     .map((token) => ({ start: token.span.start, end: token.span.end, key: stemOf(token.surface, suffixes) }));
 };
 
+/** 語彙表 name-title-joiner の、前置詞の後ろにだけ立つ冠詞（the）の組。 */
+const ARTICLE = "article";
+
 /**
  * 語の順を入れ替えて書いた同じ名前（統計学基礎 と 基礎統計学）。名前と読める所は、括弧の中（name-quote）、大文字で始まる語の並び
  * （name-title-joiner を挟んでよい）、名前を書く欄の後ろ（name-label）。大文字の語の並びどうしは、片方が表の升まるごとに
@@ -196,13 +220,20 @@ const orderWordsOf = (doc: ProseDocument): OrderWord[] => {
  */
 const orderFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] => {
   const starts = sentenceStartsOf(doc);
+  const joiners = doc.lexicons["name-title-joiner"] ?? [];
   const spans = [
     ...quotedSpans(prose, patternsOf(doc, "name-quote")),
-    ...titleCaseSpans(prose, patternsOf(doc, "name-title-joiner"), (offset) => starts.has(offset)),
+    ...titleCaseSpans(
+      prose,
+      joiners.filter((entry) => entry.group !== ARTICLE).map((entry) => entry.pattern),
+      (offset) => starts.has(offset),
+      joiners.filter((entry) => entry.group === ARTICLE).map((entry) => entry.pattern),
+    ),
     ...labelledSpans(prose, patternsOf(doc, "name-label")),
   ];
   const cells = new Set(tableBodyCells(proseAndTablesOf(doc)).map((cell) => cell.text.trim()));
-  return wordOrderVariants(orderNamesOf(doc.source, spans, orderWordsOf(doc), orderStopsOf(doc)), cells)
+  const names = notDefinedTerms(doc, orderNamesOf(doc.source, spans, orderWordsOf(doc), orderStopsOf(doc)));
+  return wordOrderVariants(names, cells, sentenceIndexOf(doc))
     .filter(({ name }) => !overlapsAny(reported, name.offset, name.surface.length))
     .map(({ name, usual }) => ({ offset: name.offset, name: name.surface, usual, kind: "order" }));
 };
@@ -220,21 +251,25 @@ const wordsCovering = (tokens: readonly Token[], startAt: ReadonlyMap<number, nu
 
 /**
  * 空白を挟んだ姓と名で、敬称か肩書きが付くか、人を書く欄にあるもの（高瀬 誠部長、氏名：森川 大輔）。語は解析器の切り方のまま、
- * 読みは語の読みをつなぐ。解析器の語の切れ目と姓・名の端が合わないものは読まない。
+ * 読みは語の読みをつなぐ。名を名の中での字の読みで読み直した読みも持つ（givenNameReading）。解析器の語の切れ目と姓・名の端が
+ * 合わないものは読まない。
  */
 const spacedNameMentionsOf = (doc: ProseDocument, prose: string, charReadings: CharReadings): NameMention[] => {
   const cues = { suffixes: patternsOf(doc, "person-suffix"), titles: patternsOf(doc, "person-title"), labels: patternsOf(doc, "person-label") };
   const tokens = tokensOf(doc);
   const startAt = new Map(tokens.map((token, index) => [token.span.start, index]));
+  const givenChars = givenCharReadingsOf(doc, charReadings);
   return spacedPersonNamesIn(prose, cues).flatMap(({ surname, given }): NameMention[] => {
     const surnameWords = wordsCovering(tokens, startAt, surname);
     const givenWords = wordsCovering(tokens, startAt, given);
     if (surnameWords === undefined || givenWords === undefined) return [];
     const words = [...surnameWords, ...givenWords];
     const surface = `${prose.slice(surname.start, surname.end)} ${prose.slice(given.start, given.end)}`;
-    return [
-      { surface, offset: surname.start, reading: readingOfWords(words, charReadings), words: words.map((word) => word.surface), person: true, cue: "person" },
-    ];
+    const surnameReading = readingOfWords(surnameWords, charReadings);
+    const givenReading = givenNameReadingOf(givenWords, givenChars, charReadings);
+    const givenNameReading = surnameReading === undefined || givenReading === undefined ? undefined : surnameReading + givenReading;
+    const reading = readingOfWords(words, charReadings);
+    return [{ surface, offset: surname.start, reading, givenNameReading, words: words.map((word) => word.surface), person: true, cue: "person" }];
   });
 };
 
@@ -248,7 +283,7 @@ const tokenRunsOf = (sentence: Sentence): readonly (readonly Token[])[] => {
 const nameMentionsOf = (doc: ProseDocument, prose: string, chars: VariantChars): NameMention[] => {
   const cues: NameCues = { leads: patternsOf(doc, "person-lead"), suffixes: patternsOf(doc, "person-suffix"), particles: patternsOf(doc, "name-particle") };
   const charReadings = charReadingsOf(doc);
-  const tagged = doc.sentences.flatMap((sentence) => tokenRunsOf(sentence).flatMap((tokens) => mentionsIn(tokens, doc.source, cues.suffixes, charReadings)));
+  const tagged = doc.sentences.flatMap((sentence) => tokenRunsOf(sentence).flatMap((tokens) => mentionsIn(tokens, prose, cues.suffixes, charReadings)));
   const taggedOrSuffixed = [...tagged, ...suffixedNamesIn(prose, cues.suffixes, chars, tagged)];
   const cued = [...taggedOrSuffixed, ...cuedNamesIn(prose, cues, chars, taggedOrSuffixed)].map((mention): NameMention => {
     const cue = mention.cue ?? nameCueAt(prose, mention.offset, mention.surface, cues);
@@ -259,7 +294,7 @@ const nameMentionsOf = (doc: ProseDocument, prose: string, chars: VariantChars):
   const outside = joined.filter(
     (mention) => !spaced.some((name) => name.offset < mention.offset + mention.surface.length && mention.offset < name.offset + name.surface.length),
   );
-  return withKnownNeighbours([...outside, ...spaced], prose).toSorted((left, right) => left.offset - right.offset);
+  return outsideCapitals(prose, withKnownNeighbours([...outside, ...spaced], prose)).toSorted((left, right) => left.offset - right.offset);
 };
 
 /** 人の名前で形の似た別の字（太 と 大）は語彙表 name-lookalike-char が組（group）ごとに言う。 */
@@ -311,14 +346,34 @@ const labelledNamesOf = (doc: ProseDocument, mentions: readonly NameMention[]):
   );
 };
 
+const LATIN_WORD = /^[A-Za-z]+$/u;
+const LOWERCASE_WORD = /^[a-z]+$/u;
+
+/** 文書が小文字で書くか、品詞解析が普通名詞と読む英字の語（文頭の Hurricane）。 */
+const isCommonToken = (token: Token): boolean => LOWERCASE_WORD.test(token.surface) || (token.pos === "NOUN" && LATIN_WORD.test(token.surface));
+
+/** 文書での英字の語の使い方。名前と読んだ語のうち小文字で書けばふつうの語と、普通名詞として書いた語。 */
+const wordUseOf = (doc: ProseDocument): WordUse => {
+  const tokens = tokensOf(doc);
+  return {
+    ordinary: new Set(tokens.flatMap((token) => (isOrdinaryToken(token) ? [token.surface.toLowerCase()] : []))),
+    common: new Set(tokens.flatMap((token) => (isCommonToken(token) ? [token.surface.toLowerCase()] : []))),
+  };
+};
+
 /** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
 export const nameVariant: Detector = (doc): Finding[] => {
   const prose = doc.prose ?? doc.source;
   const chars = variantCharsOf(doc);
-  const mentions = labelledNamesOf(doc, ordinaryNamesOf(doc, nameMentionsOf(doc, prose, chars)));
-  const variants = nameVariants(mentions, chars, spellingInputOf(doc))
+  const mentions = labelledNamesOf(doc, ordinaryNamesOf(doc, withGivenNames(tokensOf(doc), doc.source, nameMentionsOf(doc, prose, chars))));
+  const companies = companyMentionsOf(doc, prose);
+  const inGroup = isGroupPairOf(
+    companies,
+    companyFormsOf(doc).map((form) => form.pattern),
+  );
+  const variants = nameVariants(mentions, chars, spellingInputOf(doc), wordUseOf(doc))
     .map(({ mention, usual, kind }): Reported => ({ offset: mention.offset, name: mention.surface, usual, kind }))
-    .filter(notSpacingOnly);
+    .filter((found) => notSpacingOnly(found) && !inGroup(found));
   const lookalikes = lookalikeSlipsIn(mentions, lookalikeCharsOf(doc)).map(({ mention, usual }) => ({
     offset: mention.offset,
     name: mention.surface,
@@ -326,7 +381,7 @@ export const nameVariant: Detector = (doc): Finding[] => {
     kind: "lookalike",
   }));
   const names = [...variants, ...lookalikes.filter((found) => !overlapsAny(variants, found.offset, found.name.length))];
-  const namesAndCompanies = [...names, ...companyFindings(doc, prose, names)];
+  const namesAndCompanies = [...names, ...companyFindings(doc, prose, companies, names)];
   const withTables = [...namesAndCompanies, ...tableFindings(doc, prose, mentions, namesAndCompanies).filter(notSpacingOnly)];
   const withPlaces = [...withTables, ...placeFindings(doc, prose, withTables, chars)];
   const withProducts = [...withPlaces, ...productFindings(doc, prose, withPlaces)];

package/src/detectors/number-unit.ts

@@ -135,12 +135,38 @@ export const unitGaps = (values: readonly Measured[]): UnitGap[] => {
 const unitsOf = (doc: ProseDocument): Set<string> =>
   new Set(UNIT_LEXICONS.flatMap((name) => (doc.lexicons[name] ?? []).flatMap((entry) => [entry.pattern, entry.pattern.toLowerCase()])));
 
-export const numberWithoutUnit: Detector = (doc: ProseDocument): Finding[] =>
-  unitGaps(measuredValues(doc.source, doc.prose ?? doc.source, unitsOf(doc))).map((gap) => ({
-    rule: "number-without-unit",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAt(doc.source, gap.value.offset),
-    values: { value: gap.value.written, name: gap.value.name, unit: gap.unit, offset: gap.value.offset },
-  }));
+/** Lexicon piece-count-column: the headings of a column that counts whatever its row is, and the units of a hired period. */
+export type PieceCount = { readonly columns: ReadonlySet<string>; readonly periods: ReadonlySet<string> };
+
+const WHOLE_NUMBER = /^\d[\d,]*$/u;
+const TABLE_KIND = /^table \d+: /u;
+
+/**
+ * A bare whole number in a quantity column whose other rows count a hired period (4 days, 2 nights): the count of a
+ * piece the row hires or buys (Child seat | 1), which has no unit to lose.
+ */
+export const isPieceCount = (gap: UnitGap, count: PieceCount): boolean =>
+  TABLE_KIND.test(gap.value.kind) &&
+  count.columns.has(gap.value.name.toLowerCase()) &&
+  count.periods.has(gap.unit.toLowerCase()) &&
+  WHOLE_NUMBER.test(gap.value.written.normalize("NFKC"));
+
+const pieceCountOf = (doc: ProseDocument): PieceCount => {
+  const entries = doc.lexicons["piece-count-column"] ?? [];
+  const patterns = (group: string): Set<string> => new Set(entries.filter((entry) => entry.group === group).map((entry) => entry.pattern.toLowerCase()));
+  return { columns: patterns("column"), periods: patterns("period") };
+};
+
+export const numberWithoutUnit: Detector = (doc: ProseDocument): Finding[] => {
+  const count = pieceCountOf(doc);
+  return unitGaps(measuredValues(doc.source, doc.prose ?? doc.source, unitsOf(doc)))
+    .filter((gap) => !isPieceCount(gap, count))
+    .map((gap) => ({
+      rule: "number-without-unit",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, gap.value.offset),
+      values: { value: gap.value.written, name: gap.value.name, unit: gap.unit, offset: gap.value.offset },
+    }));
+};

package/src/detectors/numeral-word.ts

@@ -0,0 +1,33 @@
+/**
+ * 大文字の並びでも略語として書かれないもの。どれも字の形だけで決まる。
+ * - I だけのローマ数字（II、III）。名前の後ろでなくても番号で（Doswell, III、1964: II Structure）、この形の略語は使われない。
+ *   IV や VI のように V・X を含む数字は略語（静脈注射の IV）でもあるので、名前の番号（name-numeral.ts）の位置でだけ外す。
+ * - 大文字で始まる語に - で繋いだ I・V・X の数字（Association-IV）。名前の番号を空白でなく - で書いた形。
+ * - X を 3 つ以上並べた伏せ字（the Secretary of State for XXX）や X の数で書く染色体の型（XXX症候群）。KKK や WWW のような他の字の繰り返しは略語のまま数える。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+// 略語の切り出しと同じ境目。日本語の文字（XXX症候群）は語の続きではない。
+const NOT_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
+const NOT_AFTER = String.raw`(?![A-Za-z0-9_&])`;
+
+const ONES_NUMERAL = new RegExp(`${NOT_BEFORE}I{2,3}${NOT_AFTER}`, "gu");
+const MASK = new RegExp(`${NOT_BEFORE}X{3,}${NOT_AFTER}`, "gu");
+const SMALL_NUMERAL = "(?=[IVX])X{0,3}(?:IX|IV|V?I{0,3})";
+const JOINED_NUMERAL = new RegExp(String.raw`(?<![A-Za-z0-9_-])\p{Lu}\p{Ll}+-(?<numeral>${SMALL_NUMERAL})${NOT_AFTER}`, "gu");
+
+const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
+
+const joinedSpans = (text: string): Span[] =>
+  [...text.matchAll(JOINED_NUMERAL)].map((match) => {
+    const end = match.index + match[0].length;
+    return { start: end - (match.groups?.["numeral"] ?? "").length, end };
+  });
+
+/** 文の中の、番号か伏せ字と読む大文字の範囲。 */
+export const numeralWordSpans = (text: string): Span[] => [
+  ...[...text.matchAll(ONES_NUMERAL)].map(spanOf),
+  ...[...text.matchAll(MASK)].map(spanOf),
+  ...joinedSpans(text),
+];

package/src/detectors/organisation-run.ts

@@ -0,0 +1,86 @@
+import type { Token } from "../plugin.ts";
+
+/** 組織の名前の前に立つ形（語彙表 organisation-form）と、組織や単位の名前を閉じる語（organisation-unit）。 */
+export type OrganisationWords = { readonly forms: readonly string[]; readonly units: readonly string[] };
+
+/** 区切りの前に要る字数。1 字なら、普通の語の一部（外部・本部・課題）と見分けられない。 */
+const MIN_BODY_LENGTH = 2;
+const KANJI = /[一-鿿]/u;
+
+const surfaceOf = (tokens: readonly Token[]): string => tokens.map((token) => token.surface).join("");
+const isNumber = (token: Token): boolean => token.features?.["NumType"] === "Card";
+const isProperPiece = (token: Token): boolean => token.pos === "PROPN" || token.features?.["NameType"] === "GeoUnit";
+
+/** covering の語が、隙間なく続いて並ぶときだけ、その語の並び。改行などで割れていれば読まない。 */
+const contiguous = (tokens: readonly Token[], covering: readonly number[]): Token[] | undefined => {
+  const run = covering.flatMap((index) => tokens.slice(index, index + 1));
+  const joined = run.every((token, at) => at === 0 || run[at - 1]?.span.end === token.span.start);
+  return run.length === covering.length && joined ? run : undefined;
+};
+
+/**
+ * 連なりのすぐ後ろの語が組織の語そのもの（幼稚園運営企画グループのグループ）なら、それも足した語の並び。
+ * 漢字でない組織の語は漢字の連なりの外にあるが、名前はそこで閉じる。
+ */
+const withClosingUnit = (tokens: readonly Token[], covering: readonly number[], units: readonly string[]): number[] => {
+  const next = (covering.at(-1) ?? -1) + 1;
+  const [last, closing] = [tokens[next - 1], tokens[next]];
+  const closes =
+    covering.length > 0 &&
+    last !== undefined &&
+    closing !== undefined &&
+    last.span.end === closing.span.start &&
+    !KANJI.test(closing.surface) &&
+    units.includes(closing.surface);
+  return closes ? [...covering, next] : [...covering];
+};
+
+/** 頭の、語の切れ目で終わる組織の形（国立研究開発法人）の語数。無ければ 0。 */
+const formLength = (run: readonly Token[], forms: ReadonlySet<string>): number =>
+  run.reduce((found, _, at) => (forms.has(surfaceOf(run.slice(0, at + 1))) ? at + 1 : found), 0);
+
+/** 頭の、固有名詞と地名の単位だけの並び（紀美野町、下神野地区、気象庁）の語数。固有名詞が無ければ 0。 */
+const properLength = (run: readonly Token[]): number => {
+  const length = run.findIndex((token) => !isProperPiece(token));
+  const stretch = length === -1 ? run.length : length;
+  return run.slice(0, stretch).some((token) => token.pos === "PROPN") ? stretch : 0;
+};
+
+/** 1 つの区切り（総務課、産業技術総合研究所）か。組織の語で閉じ、その前に 2 字以上の語があり、数を含まない。 */
+const isSegment = (part: readonly Token[], units: readonly string[]): boolean => {
+  const text = [...surfaceOf(part)];
+  const closing = units.filter((unit) => text.join("").endsWith(unit));
+  return !part.some(isNumber) && closing.some((unit) => text.length - [...unit].length >= MIN_BODY_LENGTH);
+};
+
+/**
+ * run を区切りだけに割ったときの区切りの数の最大。割れなければ 0。
+ * 後ろから、各位置から終わりまでを割れる数を一度ずつ決める（長い連なりでも語数の二乗で済む）。
+ */
+const segmentCount = (run: readonly Token[], units: readonly string[]): number => {
+  const counts = run.reduceRight<number[]>((after, _, start) => {
+    const best = run.slice(start).reduce((most, __, offset) => {
+      const end = start + offset + 1;
+      const rest = after[end - start - 1] ?? 0;
+      const closesRun = end === run.length;
+      return isSegment(run.slice(start, end), units) && (closesRun || rest > 0) ? Math.max(most, 1 + rest) : most;
+    }, 0);
+    return [best, ...after];
+  }, []);
+  return counts[0] ?? 0;
+};
+
+/**
+ * 漢字の連なりの語（covering: tokens の添字）が 1 つの組織の名前か。名前は書き手が変えられない。
+ * 法人格か地名・固有名詞で始まって組織の語で閉じるもの（国立研究開発法人産業技術総合研究所、紀美野町青少年育成町民会議）、
+ * または組織の語で閉じる区切りが 2 つ以上続くもの（国土交通省鉄道局総務課）。
+ * 組織の語で閉じない連なり（情報処理推進機構認定試験、総務課長）や、頭に名前の無い 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;
+  const form = formLength(run, new Set(words.forms));
+  const head = form > 0 ? form : properLength(run);
+  const segments = segmentCount(run.slice(head), words.units);
+  return head > 0 ? segments >= 1 : segments >= 2;
+};

package/src/detectors/orthographic-variant.ts

@@ -7,8 +7,11 @@ import { nameSpans, touchesAny } from "../team-names.ts";
 import { furiganaSpans } from "../furigana.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";
 
 /**
  * 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
@@ -41,6 +44,8 @@ const FUKUSHI = "hiragana-fukushi";
 const IDIOM = "orthographic-variant-idiom";
 /** 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. */
+const PHRASE_SUFFIX = "orthographic-variant-phrase-suffix";
 
 const patternsOf = (doc: ProseDocument, id: string, genre: string | undefined): string[] =>
   entriesForGenre(doc.lexicons[id] ?? [], genre).map((entry) => entry.pattern);
@@ -121,7 +126,12 @@ const isCutFromKatakana = ({ token, previous }: InContext): boolean =>
 const isCopulaReadAsVerb = ({ token, previous }: InContext): boolean =>
   token.pos === "VERB" && token.surface === "で" && previous !== undefined && previous.pos !== "ADP";
 
-type Skips = { readonly skip: ReadonlySet<string>; readonly idioms: ReadonlySet<string>; readonly wholeWords: ReadonlyMap<string, string> };
+type Skips = {
+  readonly skip: ReadonlySet<string>;
+  readonly idioms: ReadonlySet<string>;
+  readonly wholeWords: ReadonlyMap<string, string>;
+  readonly phraseSuffixes: ReadonlySet<string>;
+};
 
 const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefined => {
   const { token } = word;
@@ -156,13 +166,14 @@ const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[
   const whole = runs.flatMap((run) => wholeWordOf(sentence, tokens, run, isOpen, skips.wholeWords));
   return [
     ...whole,
-    ...tokens.flatMap((token, at): 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 local = token.span.start - sentence.span.start;
       if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
-      const next = tokens[at + 1];
-      const compoundHead = token.pos === "NOUN" && next?.pos === "NOUN" && isTouching(token, next);
+      const compoundHead = token.pos === "NOUN" && next?.pos === "NOUN" && isTouching(token, next) && !skips.phraseSuffixes.has(next.surface);
       return [{ key, spelling: token.lemma, sentence, offset: token.span.start, compoundHead }];
     }),
   ];
@@ -260,7 +271,7 @@ const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string
     const plain = word.toLowerCase().replaceAll("-", "");
     const end = match.index + word.length;
     if (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || isCapitalsNotSpelling(word, acronyms) || skip.has(word.toLowerCase())) return [];
-    if (isPartOfAddress(sentence.text, match.index, end) || !isOpen(match.index, end)) return [];
+    if (isPartOfAddress(sentence.text, match.index, end) || !isOpen(match.index, end) || isInCapitalsPassage(sentence.text, match.index, end)) return [];
     return [{ key: `latin|${plain}`, spelling: latinSpelling(word), shown: word, sentence, offset: sentence.span.start + match.index }];
   });
 };
@@ -305,6 +316,7 @@ 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)),
     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 = doc.names ?? [];
   const placed: Place[] = [
@@ -314,7 +326,11 @@ export const orthographicVariant: Detector = (doc, options): Finding[] => {
   const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skips)));
   const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
   const runs = placed.flatMap(({ sentence, isOpen }) => katakanaRunWords(sentence, isOpen));
-  const latin = placed.flatMap(({ sentence, isOpen, readsLatin }) => (readsLatin ? latinWords(sentence, isOpen, skips.skip) : []));
+  const dictionary = doc.dictionary?.();
+  const latin = withoutCoinedNames(
+    placed.flatMap(({ sentence, isOpen, readsLatin }) => (readsLatin ? latinWords(sentence, isOpen, skips.skip) : [])),
+    (word) => dictionary?.has(word) ?? true,
+  );
   const odd = [reading, katakana, latin].flatMap((words) => oddSpellings(words, options.limit));
   const oddRuns = oddSpellings(runs, options.limit).filter(({ word }) => !odd.some((other) => coversOffset(word, other.word.offset)));
   const all = [...reading, ...katakana, ...runs, ...latin];

package/src/detectors/orthography.ts

@@ -1,18 +1,26 @@
-import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { conjugatedStartsOutside } from "./conjugated-entry.ts";
 import { calendarRuns, calendarUnitsOf, type CalendarUnits } from "../calendar-number.ts";
 import { escapeRegExp, latinBoundaries, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
-import { minorityReport } from "../spacing-minority.ts";
+import { minorityReport, withoutSideOnTie } from "../spacing-minority.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStarts, type NameContext } from "../number-name.ts";
 import { isSpacedLocationPart, type FloorWords } from "../location-part.ts";
-import { isNameSeparator, type OrganizationWords } from "../name-separator.ts";
+import { isFieldSeparator, isNameSeparator, type OrganizationWords } from "../name-separator.ts";
 import { addressSpans, clockTimeSpans, identifierSpans, isInsideSpan } from "../spacing-code.ts";
 
+/** 書いた形の出現に、動詞の活用した形（行う → 行います）を足したもの。同じ位置は一度だけ。 */
+const avoidedStarts = (sentence: Sentence, entry: LexiconEntry, use: string): number[] => {
+  const written = occurrencesOutside(sentence.text, entry.pattern, use);
+  const conjugated = conjugatedStartsOutside(sentence, entry, use).filter((at) => !written.includes(at));
+  return [...written, ...conjugated].toSorted((left, right) => left - right);
+};
+
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
-  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ avoid: entry.pattern, use: entry.instead_of }]));
+  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ entry, avoid: entry.pattern, use: entry.instead_of }]));
   const hits = doc.sentences.flatMap((sentence) =>
-    pairs.flatMap((pair) => occurrencesOutside(sentence.text, pair.avoid, pair.use).map((at) => ({ sentence, at, pair }))),
+    pairs.flatMap((pair) => avoidedStarts(sentence, pair.entry, pair.use).map((at) => ({ sentence, at, pair }))),
   );
   if (hits.length === 0 || hits.length < options.limit) return [];
   return hits.map((hit) => ({
@@ -91,7 +99,7 @@ type SentenceCodes = {
  * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。コロンで書いた時刻（13:30）も同じ。
  * メールアドレス・URL の前後の境目も数えない（spacing-code.ts）。「予約番号 MN-48215 を」の番号の前後も、番号を文から区切る空白なので数えない。
  * 「本社 5階」のように名前の後ろに空白で区切った階・部屋の番号の前の空白も、所在の組の区切りなので数えない（location-part.ts）。
- * 「経営企画部 IR担当」のように名前だけを並べた行で、名前と名前を分ける空白も数えない（name-separator.ts）。
+ * 「経営企画部 IR担当」のように名前だけを並べた行で、名前と名前を分ける空白も、「所属：経済学科 1年」のように項目の値の組を分ける空白も数えない（name-separator.ts）。
  */
 const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, codes: SentenceCodes): boolean => {
   if (followsItemNumber(sentence.text, boundary, context.itemNumbers) || besideSpan(codes.identifiers, boundary)) return false;
@@ -103,6 +111,7 @@ const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContex
   if (run === undefined) return true;
   if (codes.calendar.has(run.start)) return false;
   if (boundary.kind === "before-digit" && isSpacedLocationPart(sentence.text, run, sentence.tokens, sentence.span.start, context.floors)) return false;
+  if (isFieldSeparator(sentence.text, boundary, sentence.tokens, sentence.span.start)) return false;
   return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context);
 };
 
@@ -135,9 +144,9 @@ const findingAt = (entry: Located, values: Finding["values"], variant?: string):
   values: { ...values, offset: entry.sentence.span.start + entry.offset },
 });
 
-/** 一つの種類の境目の指摘。少ないほうを 1 箇所ずつか、書き方が二通りあれば 1 件で（spacing-minority.ts）。 */
+/** 一つの種類の境目の指摘。少ないほうを 1 箇所ずつか、書き方が二通りあれば 1 件で（spacing-minority.ts）。同数ならどちらの側にも立たない。 */
 const findingsOf = (kind: SpacingKind, ofKind: readonly Located[], limit: number): Finding[] => {
-  const report = minorityReport(ofKind, limit);
+  const report = withoutSideOnTie(minorityReport(ofKind, limit), ofKind);
   if (report === undefined) return [];
   if (report.mode === "mixed") {
     const { first, odd, spaced, touching } = report;

package/src/detectors/outline-label.ts

@@ -0,0 +1,48 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 行頭の、文字で振った見出しの番号（議事録の Z. の次の AA.、AB. … BZ.）。表計算の列名と同じく A〜Z の次は AA と進む。
+ * 略語ではない。行頭で . か ) が続き、その前か後の番号も同じ文書の行頭にあるときだけ番号と読む。1 か所だけの
+ * 行頭の大文字（IT. の説明、FAQ) の行）は略語のまま数える。そう読めた番号を区切りの名前の後ろで指す所（See Attachment AA）も
+ * 番号。区切りの名前は言語パッケージの語彙表から読む。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const LABEL = /^[ \t]*(?<label>[A-Z]{1,3})[.)](?=[ \t]|$)/gmu;
+const ALPHABET = 26;
+const CODE_BEFORE_A = 64;
+
+/** A=1、Z=26、AA=27、AZ=52、BA=53。 */
+const positionOf = (label: string): number => [...label].reduce((total, letter) => total * ALPHABET + (letter.charCodeAt(0) - CODE_BEFORE_A), 0);
+
+type Label = { readonly text: string; readonly position: number; readonly span: Span };
+
+const labelsOf = (source: string): Label[] =>
+  [...source.matchAll(LABEL)].map((match) => {
+    const text = match.groups?.["label"] ?? "";
+    const start = match.index + match[0].indexOf(text);
+    return { text, position: positionOf(text), span: { start, end: start + text.length } };
+  });
+
+const lineLabels = (source: string): Label[] => {
+  const labels = labelsOf(source);
+  const positions = new Set(labels.map((label) => label.position));
+  return labels.filter(({ position }) => positions.has(position - 1) || positions.has(position + 1));
+};
+
+const referenceSpans = (source: string, labels: readonly Label[], divisions: readonly string[]): Span[] => {
+  const texts = [...new Set(labels.map((label) => label.text))];
+  if (texts.length === 0 || divisions.length === 0) return [];
+  const pattern = new RegExp(String.raw`(?<![A-Za-z0-9_])(?:${divisions.map(escapeRegExp).join("|")})\s+(?<label>${texts.join("|")})(?![A-Za-z0-9_&])`, "gu");
+  return [...source.matchAll(pattern)].map((match) => {
+    const end = match.index + match[0].length;
+    return { start: end - (match.groups?.["label"] ?? "").length, end };
+  });
+};
+
+/** 文書の中の、隣の番号と並んだ文字の番号と、それを区切りの名前の後ろで指す所の範囲。位置は文書の頭からの文字数。 */
+export const outlineLabelSpans = (source: string, divisions: readonly string[]): Span[] => {
+  const labels = lineLabels(source);
+  return [...labels.map((label) => label.span), ...referenceSpans(source, labels, divisions)];
+};

package/src/detectors/page-marker.ts

@@ -0,0 +1,26 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { LengthUnit } from "../plugin.ts";
+
+/**
+ * Page markers a converted print edition leaves inside a sentence ("( printed page 52044)", "[[Page 52044]]", 「－12－」).
+ * They are the page break, not the writer's words. The shapes come from the lexicon: "#" stands for the page number and a
+ * space for any run of spaces, none included. A marker touching a digit is part of a number (an address, 1－2－3).
+ */
+const NUMBER = "#";
+
+const TEMPLATE_PARTS: Readonly<Record<string, string>> = { [NUMBER]: String.raw`\p{Nd}+`, " ": String.raw`\s*` };
+
+const templatePattern = (template: string): string => [...template].map((char) => TEMPLATE_PARTS[char] ?? escapeRegExp(char)).join("");
+
+/** One pattern for every page marker the lexicon names, or undefined when it names none. */
+export const pageMarkerPattern = (templates: readonly string[]): RegExp | undefined =>
+  templates.length === 0 ? undefined : new RegExp(String.raw`(?<!\p{Nd})(?:${templates.map(templatePattern).join("|")})(?!\p{Nd})`, "gu");
+
+const sizeOf = (marker: string, unit: LengthUnit): number =>
+  unit === "word" ? marker.split(/\s+/u).filter((word) => word.length > 0).length : marker.replace(/\s+/gu, "").length;
+
+/** How much of a sentence its page markers take up, in the document's unit: their words, or their characters without spaces. */
+export const pageMarkerSize = (text: string, pattern: RegExp | undefined, unit: LengthUnit): number => {
+  if (pattern === undefined) return 0;
+  return [...text.matchAll(pattern)].map((match) => match[0]).reduce((size, marker) => size + sizeOf(marker, unit), 0);
+};