chaffjs 0.34.0 → 0.36.0

package/src/detectors/opening-date.ts

@@ -0,0 +1,47 @@
+// The date in a document's opening lines: a line that is only a date, or a labelled one, under the title ("January 17,
+// 2024" below a centred heading in plain-text minutes, where the indented title block is no paragraph). Pure.
+import type { Span } from "../plugin.ts";
+import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
+
+/** How many non-blank lines after the front matter make the title block. */
+const OPENING_LINES = 5;
+/** How many lines from the top are read at most, blank ones and front matter included. */
+const LINE_REACH = 64;
+const FRONT_MATTER_FENCE = "---";
+
+export type DatedSpan = Span & { readonly value: string };
+
+type Line = Span & { readonly text: string };
+
+const firstLines = (source: string): Line[] =>
+  source.split("\n", LINE_REACH).reduce<Line[]>((lines, text) => {
+    const start = (lines.at(-1)?.end ?? -1) + 1;
+    lines.push({ start, end: start + text.length, text });
+    return lines;
+  }, []);
+
+/** The lines after a Markdown front matter block ("---" … "---" at the very top), or all of them. */
+const afterFrontMatter = (lines: readonly Line[]): readonly Line[] => {
+  if (lines[0]?.text.trim() !== FRONT_MATTER_FENCE) return lines;
+  const close = lines.findIndex((line, index) => index > 0 && line.text.trim() === FRONT_MATTER_FENCE);
+  return close === -1 ? lines : lines.slice(close + 1);
+};
+
+const openingLines = (source: string): Line[] =>
+  afterFrontMatter(firstLines(source))
+    .filter((line) => line.text.trim() !== "")
+    .slice(0, OPENING_LINES);
+
+const firstDateIn = (dates: readonly DatedSpan[], line: Span | undefined): string | undefined =>
+  line === undefined ? undefined : dates.find((date) => date.start >= line.start && date.end <= line.end)?.value;
+
+/**
+ * The first date of the first opening line that is a date stamp, as the tree reads it ("2024-01-17"). A label on a line of
+ * its own ("Date:") takes the date on the line after it.
+ */
+export const openingDateOf = (source: string, dates: readonly DatedSpan[], labels: readonly string[]): string | undefined => {
+  const lines = openingLines(source);
+  const stamps = dateStampIndexes(stampCandidates(source, lines, dates), labels);
+  const at = lines.findIndex((_, index) => stamps.has(index));
+  return at === -1 ? undefined : (firstDateIn(dates, lines[at]) ?? firstDateIn(dates, lines[at + 1]));
+};

package/src/detectors/ordinary-phrase.ts

@@ -0,0 +1,62 @@
+// Where a lower-case word that a defined term shares is the ordinary word in a phrase of its own, not the term, and where
+// a quoted term is named rather than used. Pure: the tokens, the source and the lexicons' words are passed in.
+import type { Token } from "../plugin.ts";
+
+/** Words that narrow a noun into a kind of its own (a common parent, a limited liability company). */
+const NARROWING = new Set(["ADJ", "NOUN"]);
+const LOWER_START = /^\p{Ll}/u;
+/** How far back from an opening quote the words that name it as a term are looked for. */
+const CUE_LOOK_BACK = 40;
+const LETTER = /\p{L}/u;
+const LATIN = /\p{Script=Latin}/u;
+
+/**
+ * An adjective or a noun of the same Latin-script phrase right before the use narrows it into a phrase of its own (the
+ * common parent, a limited liability company), unless it is a word that points at the defined thing (the other party).
+ */
+export const isNarrowedUse = (tokens: readonly Token[], at: number, pointers: readonly string[]): boolean => {
+  const before = tokens[at - 1];
+  if (before === undefined || !NARROWING.has(before.pos) || !LATIN.test(before.surface)) return false;
+  return !pointers.some((pointer) => pointer.toLowerCase() === before.surface.toLowerCase());
+};
+
+/**
+ * The use heads a phrase that names a kind of thing with "of" and a bare noun (certificates of deposit, letters of credit);
+ * "of" followed by an article, a pronoun or a name (the certificate of the Company) is the defined thing again.
+ * last is the index of the use's last token.
+ */
+export const headsKindPhrase = (tokens: readonly Token[], last: number): boolean => {
+  const of = tokens[last + 1];
+  const noun = tokens[last + 2];
+  return of !== undefined && noun !== undefined && of.surface.toLowerCase() === "of" && noun.pos === "NOUN" && LOWER_START.test(noun.surface);
+};
+
+/** Every position of part inside whole, overlapping ones too. */
+const positionsOf = (whole: string, part: string): number[] =>
+  Array.from({ length: whole.length }, (_, index) => index).filter((index) => part !== "" && whole.startsWith(part, index));
+
+/** The use sits inside another defined term written out in any case (certificate of merger, where Certificate of Merger is defined). */
+export const insideLongerTerm = (source: string, offset: number, term: string, defined: readonly string[]): boolean =>
+  defined.some((longer) => {
+    if (longer.length <= term.length) return false;
+    const lowerLonger = longer.toLowerCase();
+    return positionsOf(lowerLonger, term.toLowerCase()).some((at) => {
+      const start = offset - at;
+      return start >= 0 && source.slice(start, start + longer.length).toLowerCase() === lowerLonger;
+    });
+  });
+
+/**
+ * A quoted term that the words before its opening quote name as a term (the definition of "Material Adverse Effect",
+ * the term "Affiliate"): the term is mentioned, not used again. opening is the offset of the opening quote.
+ */
+export const isNamedAsTerm = (source: string, opening: number, cues: readonly string[]): boolean => {
+  const before = source
+    .slice(Math.max(0, opening - CUE_LOOK_BACK), opening)
+    .trimEnd()
+    .toLowerCase();
+  return cues.some((cue) => {
+    const lower = cue.toLowerCase();
+    return lower !== "" && before.endsWith(lower) && !LETTER.test(before.charAt(before.length - lower.length - 1));
+  });
+};

package/src/detectors/organisation-run.ts

@@ -0,0 +1,97 @@
+import type { Token } from "../plugin.ts";
+
+/**
+ * 組織の名前の前に立つ形（語彙表 organisation-form）、そのうち名前の後ろにも立つ法人格（closingForms。株式会社、監査法人）と、
+ * 組織や単位の名前を閉じる語（organisation-unit）。
+ */
+export type OrganisationWords = { readonly forms: readonly string[]; readonly closingForms: 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;
+};
+
+/**
+ * 法人格で閉じ、その前に 2 字以上の名前がある（東日本自動車販売株式会社、青葉監査法人）。数を含む連なり（2024年株式会社、第三東京販売株式会社）は名前と読まない。
+ * 呼び出し側は、名前に固有名詞か地名があることも求める。法令の語（株式交換完全親株式会社）は法人格で閉じても名前ではない。
+ */
+const endsInForm = (text: string, closingForms: readonly string[]): boolean =>
+  !/[0-9０-９]/u.test(text) && closingForms.some((form) => text.endsWith(form) && [...text].length - [...form].length >= MIN_BODY_LENGTH);
+
+/**
+ * 漢字の連なりの語（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;
+  if (endsInForm(surfaceOf(run), words.closingForms) && run.some(isProperPiece) && !run.some(isNumber)) return true;
+  const form = formLength(run, new Set(words.forms));
+  const head = form > 0 ? form : properLength(run);
+  const segments = segmentCount(run.slice(head), words.units);
+  return head > 0 ? segments >= 1 : segments >= 2;
+};

package/src/detectors/orthographic-variant.ts

@@ -1,14 +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, 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
@@ -39,24 +47,48 @@ 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. */
+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);
 
 /**
- * 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;
@@ -94,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";
@@ -121,15 +172,24 @@ 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 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}`;
 };
 
 /**
@@ -150,19 +210,20 @@ 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));
   return [
     ...whole,
-    ...tokens.flatMap((token, at): Placed[] => {
+    ...tokens.flatMap((written, at): Placed[] => {
       if (inRun.has(at)) return [];
-      const key = readingKeyOf({ token, previous: tokens[at - 1], before: tokens[at - 2] }, skips);
+      const next = tokens[at + 1];
+      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 next = tokens[at + 1];
-      const compoundHead = token.pos === "NOUN" && next?.pos === "NOUN" && isTouching(token, next);
+      const compoundHead = isCompoundHead(token, tokens, at, skips.phraseSuffixes);
       return [{ key, spelling: token.lemma, sentence, offset: token.span.start, compoundHead }];
     }),
   ];
@@ -260,7 +321,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 }];
   });
 };
@@ -289,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()) };
@@ -301,20 +362,35 @@ 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])),
+  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 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

@@ -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/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/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/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);
+};