chaffjs 0.27.1 → 0.29.0

package/src/detectors/en-shape.ts

@@ -1,7 +1,8 @@
 import { lengthOf } from "../measure.ts";
 import { isClosed } from "../sentence-shape.ts";
 import { isTitleCase, minorityCase, pageTitleOf } from "./heading-case.ts";
-import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
+import { entryOpens } from "./lexicon-match.ts";
 
 const PER = 1000;
 
@@ -74,21 +75,36 @@ const firstWord = (sentence: Sentence): string =>
     .split(/\s+/u)[0]
     ?.replace(/[^A-Za-z]/gu, "") ?? "";
 
-/**
- * 接続詞で始まる文が続く。1 つなら効くが、続くと文が前の文の付け足しに見えて、
- * 何が主張なのかが分からなくなる。
- */
-export const conjunctionRun: Detector = (doc, options): Finding[] => {
-  const heads = new Set((options.lexicon ?? []).map((entry) => entry.pattern.toLowerCase()));
-  const runs = doc.sentences.filter(isClosed).reduce<Sentence[][]>(
+/** A head written as one Latin word ("And") is read off the first word; any other (しかし) off the tokens, since Japanese has no spaces. */
+const LATIN_WORD = /^[A-Za-z]+$/u;
+
+type Heads = { readonly latin: ReadonlySet<string>; readonly other: Lexicon };
+
+const headsOf = (lexicon: Lexicon): Heads => ({
+  latin: new Set(lexicon.filter((entry) => LATIN_WORD.test(entry.pattern)).map((entry) => entry.pattern.toLowerCase())),
+  other: lexicon.filter((entry) => !LATIN_WORD.test(entry.pattern)),
+});
+
+const opensWithHead = (sentence: Sentence, heads: Heads): boolean =>
+  heads.latin.has(firstWord(sentence).toLowerCase()) || (sentence.tokens !== undefined && heads.other.some((entry) => entryOpens(sentence, entry)));
+
+const headRuns = (sentences: readonly Sentence[], heads: Heads): Sentence[][] =>
+  sentences.filter(isClosed).reduce<Sentence[][]>(
     (acc, sentence) => {
       const last = acc.at(-1) ?? [];
-      if (!heads.has(firstWord(sentence).toLowerCase())) return [...acc.slice(0, -1), last, []];
+      if (!opensWithHead(sentence, heads)) return [...acc.slice(0, -1), last, []];
       return [...acc.slice(0, -1), [...last, sentence]];
     },
     [[]],
   );
-  return runs
+
+/**
+ * 接続詞で始まる文が続く。1 つなら効くが、続くと文が前の文の付け足しに見えて、
+ * 何が主張なのかが分からなくなる。
+ */
+export const conjunctionRun: Detector = (doc, options): Finding[] => {
+  const joiner = doc.lengthUnit === "char" ? "" : " ";
+  return headRuns(doc.sentences, headsOf(options.lexicon ?? []))
     .filter((run) => run.length > options.limit)
     .flatMap((run) => {
       const first = run[0];
@@ -100,7 +116,7 @@ export const conjunctionRun: Detector = (doc, options): Finding[] => {
               severity: "info" as const,
               line: 0,
               column: 0,
-              quote: run.map((sentence) => sentence.text.trim()).join(" "),
+              quote: run.map((sentence) => sentence.text.trim()).join(joiner),
               values: { count: run.length, limit: options.limit, offset: first.span.start },
             },
           ];

package/src/detectors/fact-consistency.ts

@@ -1,10 +1,13 @@
 import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { countedFacts, countedPhraseAt, type CountedPhrase } from "../facts/counted-facts.ts";
 import { nameSpans } from "../compare/proper-nouns.ts";
 import { factValues, type FactValue } from "../facts/fact-values.ts";
 import { labelledFacts, type AttributePhrase, type FactWords } from "../facts/labelled-facts.ts";
 import { tableFacts } from "../facts/table-facts.ts";
-import { scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
+import { partsAt, scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
+import { conditionPairConflicts, type ChangeSentence, type ChangeWords, type ConditionWord, type PairConflict, type WordAt } from "../facts/condition-pairs.ts";
 import { scopeConflicts, summaryConflicts, type FactConflict } from "../facts/fact-conflicts.ts";
+import { eventDateConflicts, type EventDateConflict, type EventWord } from "../facts/event-dates.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
@@ -14,6 +17,7 @@ export const factWordsOf = (doc: ProseDocument): FactWords => ({
   valueEnds: patternsOf(doc, "fact-value-end"),
   determiners: patternsOf(doc, "fact-label-drop"),
   vague: patternsOf(doc, "fact-label-vague"),
+  leads: patternsOf(doc, "fact-label-lead"),
   attributes: (doc.lexicons["fact-attribute"] ?? []).map((entry): AttributePhrase => ({ pattern: entry.pattern, position: entry.position ?? "before" })),
 });
 
@@ -50,5 +54,109 @@ const findingOf =
 /** 同じ節で、同じ名前に二通りの値（締切：10月5日 と 締切：10月7日）。 */
 export const factConflict: Detector = (doc): Finding[] => scopeConflicts(factsOf(doc)).map(findingOf("fact-conflict", doc));
 
+const countedPhrasesOf = (doc: ProseDocument): CountedPhrase[] =>
+  doc.sentences.flatMap((sentence) => {
+    const tokens = sentence.tokens ?? [];
+    return tokens.flatMap((token, index) => (token.pos === "NUM" ? countedPhraseAt(tokens, index) : []));
+  });
+
+/** The values named by what they count, scoped like the labelled ones. Only the summary is compared with them. */
+const countedFactsOf = (doc: ProseDocument): ScopedFact[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const values = factValues(tree, doc.source, nameSpans(doc));
+  return scopedFacts(countedFacts(doc.source, values, countedPhrasesOf(doc)), tree, doc.source, patternsOf(doc, "summary-heading"));
+};
+
+const wordsAt = (doc: ProseDocument, id: string): WordAt[] =>
+  (doc.lexicons[id] ?? []).map((entry): WordAt => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+const conditionsOf = (doc: ProseDocument, id: string): ConditionWord[] =>
+  (doc.lexicons[id] ?? []).map((entry): ConditionWord => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+const changeWordsOf = (doc: ProseDocument): ChangeWords => ({
+  from: wordsAt(doc, "fact-change-from"),
+  to: wordsAt(doc, "fact-change-to"),
+  notChange: patternsOf(doc, "fact-change-not"),
+  subjectMarks: patternsOf(doc, "fact-change-subject-mark"),
+  joiners: wordsAt(doc, "fact-name-joiner"),
+  conditionsFrom: conditionsOf(doc, "fact-condition-from"),
+  conditionsTo: conditionsOf(doc, "fact-condition-to"),
+});
+
+const changeSentencesOf = (doc: ProseDocument, tree: StructureNode): ChangeSentence[] => {
+  const parts = partsAt(
+    doc.sentences.map((sentence) => sentence.span.start),
+    tree,
+    patternsOf(doc, "summary-heading"),
+  );
+  return doc.sentences.map((sentence, index) => ({
+    span: sentence.span,
+    text: sentence.text,
+    tokens: sentence.tokens ?? [],
+    summary: parts[index] !== "body",
+  }));
+};
+
+const ARROW = " → ";
+
+const pairFinding =
+  (doc: ProseDocument) =>
+  ({ summary, body }: PairConflict): Finding => ({
+    rule: "summary-fact-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, summary.from.start),
+    values: {
+      label: summary.subject,
+      value: [shown(doc, summary.from), shown(doc, summary.to)].join(ARROW),
+      other: [shown(doc, body.from), shown(doc, body.to)].join(ARROW),
+      offset: summary.from.start,
+    },
+  });
+
+/** 要約の「XからYに」が、本文が条件で分けて書いた同じ名前の二つの値と違う。 */
+const conditionPairFindings = (doc: ProseDocument): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const values = factValues(tree, doc.source, nameSpans(doc));
+  return conditionPairConflicts(doc.source, changeSentencesOf(doc, tree), values, changeWordsOf(doc)).map(pairFinding(doc));
+};
+
+const eventWordsOf = (doc: ProseDocument): EventWord[] =>
+  (doc.lexicons["fact-event"] ?? []).map((entry): EventWord => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+const eventDateFinding =
+  (doc: ProseDocument) =>
+  ({ label, value, other }: EventDateConflict): Finding => ({
+    rule: "summary-fact-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, value.start),
+    values: { label, value: shown(doc, value), other: shown(doc, other), offset: value.start },
+  });
+
+/** 冒頭や要約の出来事の日付（11月9日から提供します）が、本文の同じ出来事の日付と違う。 */
+const eventDateFindings = (doc: ProseDocument): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const values = factValues(tree, doc.source, nameSpans(doc));
+  const dates = values.filter((value) => value.kind === "date");
+  const names = values.filter((value) => value.kind === "name");
+  const sentences = changeSentencesOf(doc, tree).map(({ span, text, summary }) => ({
+    ...span,
+    text,
+    summary,
+    names: names.filter((name) => span.start <= name.start && name.end <= span.end).map((name) => name.key),
+  }));
+  return eventDateConflicts(sentences, dates, eventWordsOf(doc)).map(eventDateFinding(doc));
+};
+
 /** 冒頭や要約の値が、本文の同じ名前の値と違う。 */
-export const summaryFactMismatch: Detector = (doc): Finding[] => summaryConflicts(factsOf(doc)).map(findingOf("summary-fact-mismatch", doc));
+export const summaryFactMismatch: Detector = (doc): Finding[] => [
+  ...summaryConflicts([...factsOf(doc), ...countedFactsOf(doc)]).map(findingOf("summary-fact-mismatch", doc)),
+  ...conditionPairFindings(doc),
+  ...eventDateFindings(doc),
+];

package/src/detectors/heading-echo.ts

@@ -3,6 +3,7 @@ import { newContentMorphemes } from "./content-morphemes.ts";
 import { echoedHeadingUnits, trigrams } from "./heading-overlap.ts";
 import { titleTokens } from "../heading-label.ts";
 import { handsOver } from "./lead-in.ts";
+import { holdsLink, namesLocation } from "./location-pointer.ts";
 import { withoutQuotedVariants } from "./quoted-variant.ts";
 import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
 
@@ -55,6 +56,15 @@ const leadsIn = (doc: ProseDocument, section: Section, phrases: readonly string[
   return first !== undefined && handsOver(first.text, doc.source.slice(first.span.end, section.span.end), phrases);
 };
 
+/**
+ * 最初の文が、中身の置き場所（ページの外へのリンク・URL・コードで書いたファイルのパス）へ読者を渡している。
+ * 置き場所はコードやリンク先として本文から外れるので、残った文（The full reference is in .）は見出しの語だけに見える。
+ */
+const pointsElsewhere = (doc: ProseDocument, section: Section): boolean => {
+  const first = section.firstSentence;
+  return first !== undefined && (holdsLink(doc.source, first.span, doc.links) || namesLocation(doc.source.slice(first.span.start, first.span.end)));
+};
+
 /** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
 const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", measuredHeading(section));
 
@@ -62,7 +72,7 @@ export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
   return doc.sections
     .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
-    .filter((section) => !leadsIn(doc, section, leadIns))
+    .filter((section) => !leadsIn(doc, section, leadIns) && !pointsElsewhere(doc, section))
     .map((section) => ({ section, overlap: Math.round(containment(trigrams(measuredHeading(section)), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({

package/src/detectors/kana-function-word.ts

@@ -0,0 +1,71 @@
+import type { Detector, Finding, Lexicon, LexiconEntry, Token } from "../plugin.ts";
+
+// A helper verb or formal noun written in kanji where a style writes it in kana (見て下さい → 見てください). The word
+// list says which words and how each is told apart from its main use (資料を下さい, 本を置く, 事が起きる); this file
+// reads that off the tagger's marks. Pure: the tokens and the word list come in.
+
+export type KanaSpelling = { readonly written: string; readonly preferred: string; readonly offset: number };
+
+const TE_FORM = new Set(["て", "で"]);
+
+const followsTeForm = (previous: Token | undefined): boolean => previous?.pos === "SCONJ" && TE_FORM.has(previous.surface);
+
+const isBound = (token: Token): boolean => token.features?.["Bound"] === "Yes";
+
+const isFormalNoun = (token: Token): boolean => token.features?.["NounType"] === "Dependent";
+
+const TOPIC = "は";
+const CASE_NI = "に";
+
+/** 〜時は and 〜時には: a condition. 〜時から, 〜時に (a point in time) are not. */
+const beforeTopic = (tokens: readonly Token[], index: number): boolean =>
+  tokens[index + 1]?.surface === TOPIC || (tokens[index + 1]?.surface === CASE_NI && tokens[index + 2]?.surface === TOPIC);
+
+/** Whether the word at index is used as the list's group says: a helper after て, a formal noun, a condition (〜時は, 〜時には). */
+const usedAsFunctionWord = (group: string | undefined, tokens: readonly Token[], index: number): boolean => {
+  const token = tokens[index];
+  if (token === undefined) return false;
+  if (group === "auxiliary") return isBound(token) || followsTeForm(tokens[index - 1]);
+  if (group === "after-te") return followsTeForm(tokens[index - 1]);
+  if (group === "formal-noun") return isFormalNoun(token);
+  if (group === "conditional") return isFormalNoun(token) && beforeTopic(tokens, index);
+  return false;
+};
+
+const KANJI = /^\p{Script=Han}+/u;
+
+/** The written word with its kanji stem in kana: 下さい with 下さる → くださる gives ください. Undefined when the entry or the word does not fit. */
+export const inKana = (written: string, entry: LexiconEntry): string | undefined => {
+  const stem = KANJI.exec(entry.pattern)?.[0];
+  const rewrite = entry.rewrite;
+  if (stem === undefined || rewrite === undefined || !written.startsWith(stem)) return undefined;
+  const okurigana = entry.pattern.slice(stem.length);
+  if (!rewrite.endsWith(okurigana)) return undefined;
+  return `${rewrite.slice(0, rewrite.length - okurigana.length)}${written.slice(stem.length)}`;
+};
+
+const entryFor = (token: Token, lexicon: Lexicon): LexiconEntry | undefined =>
+  lexicon.find((entry) => entry.pattern === token.lemma && token.surface.startsWith(entry.pattern.charAt(0)));
+
+/** Each word in the tokens that the word list writes in kana, used as its group says. */
+export const kanaSpellingsIn = (tokens: readonly Token[], lexicon: Lexicon): KanaSpelling[] =>
+  tokens.flatMap((token, index) => {
+    const entry = entryFor(token, lexicon);
+    if (entry === undefined || !usedAsFunctionWord(entry.group, tokens, index)) return [];
+    const preferred = inKana(token.surface, entry);
+    return preferred === undefined ? [] : [{ written: token.surface, preferred, offset: token.span.start }];
+  });
+
+export const kanaFunctionWord: Detector = (doc, options): Finding[] => {
+  const lexicon = options.lexicon ?? [];
+  const found = doc.sentences.flatMap((sentence) => kanaSpellingsIn(sentence.tokens ?? [], lexicon).map((spelling) => ({ sentence, spelling })));
+  if (found.length < options.limit) return [];
+  return found.map(({ sentence, spelling }) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: sentence.text.trim(),
+    values: { matched: spelling.written, preferred: spelling.preferred, offset: spelling.offset },
+  }));
+};

package/src/detectors/line-amount.ts

@@ -0,0 +1,33 @@
+// line-amount-mismatch: the reading half. The column names come from the language's lexicons (quantity-column,
+// unit-price-column, line-amount-column), the units from rate-unit and per-unit-mark; the tables are read from the prose with its tables put back, so code is not.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { lineAmountMismatches, type LineAmountWords } from "../structure/line-amount.ts";
+import type { UnitWord } from "../structure/line-amount-unit.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const unitWordsOf = (doc: ProseDocument, ...lexicons: string[]): UnitWord[] =>
+  lexicons.flatMap((lexicon) =>
+    (doc.lexicons[lexicon] ?? []).flatMap((entry) => (entry.group === undefined ? [] : [{ pattern: entry.pattern, unit: entry.group }])),
+  );
+
+const wordsOf = (doc: ProseDocument): LineAmountWords => ({
+  quantity: patternsOf(doc, "quantity-column"),
+  unitPrice: patternsOf(doc, "unit-price-column"),
+  amount: patternsOf(doc, "line-amount-column"),
+  units: unitWordsOf(doc, "rate-unit"),
+  perUnitMarks: unitWordsOf(doc, "per-unit-mark"),
+  headerUnits: unitWordsOf(doc, "quantity-column", "unit-price-column"),
+});
+
+export const lineAmount: Detector = (doc): Finding[] =>
+  lineAmountMismatches(proseAndTablesOf(doc), wordsOf(doc)).map((issue) => ({
+    rule: "line-amount-mismatch",
+    severity: "error",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));

package/src/detectors/location-pointer.ts

@@ -0,0 +1,30 @@
+// Whether a sentence names where its content lives: a link, a web address, or a file in code. Pure.
+import { bareUrls } from "../bare-url.ts";
+import type { Span } from "../plugin.ts";
+
+/** A code span: a run of backticks, then the same run closing it, neither run touching another backtick. */
+const CODE_SPAN = /(?<!`)(`+)(?!`)(.+?)(?<!`)\1(?!`)/gsu;
+
+/** A link to a place on the same page (`[text](#id)`): the reader is already on that page. */
+const IN_PAGE_LINK = /\]\(\s*<?#[^)]*\)$/u;
+
+/** A page a reader opens, as a file name: README.md, guide.html, spec.pdf. A source file (main.go) names code, not a page. */
+const PAGE_FILE = /\.(?:md|markdown|mdx|txt|rst|adoc|html?|pdf)$/iu;
+
+const SEPARATOR = /[/\\]/u;
+const LETTER = /\p{L}/u;
+
+/** Code that is a path (docs/api.md, ./config, src\index) or a page file, not an identifier or an expression. */
+const isLocationCode = (code: string): boolean => {
+  const written = code.trim();
+  if (written.length === 0 || /\s/u.test(written) || !LETTER.test(written)) return false;
+  return SEPARATOR.test(written) || PAGE_FILE.test(written);
+};
+
+/** The sentence as written names a web address or, in code, a path or a page file. */
+export const namesLocation = (written: string): boolean =>
+  bareUrls(written).length > 0 || [...written.matchAll(CODE_SPAN)].some((match) => isLocationCode(match[2] ?? ""));
+
+/** One of the links written in the sentence's span leads off the page. */
+export const holdsLink = (source: string, sentence: Span, links: readonly Span[]): boolean =>
+  links.some((link) => link.start < sentence.end && link.end > sentence.start && !IN_PAGE_LINK.test(source.slice(link.start, link.end)));

package/src/detectors/mark-shape.ts

@@ -147,7 +147,24 @@ const reportFrom = (hits: readonly Hit[], limit: number): Finding[] => (hits.len
 /** A spaced hyphen or a double hyphen between words, standing for a dash ("late - very late", "late--very late"). */
 const HYPHEN_DASH = /(?<=[\p{L},;)]) -{1,2} (?=[\p{L}(])|(?<=\p{L})--(?=\p{L})/gu;
 
-export const hyphenDash: Detector = (doc, options): Finding[] => reportFrom(hitsOf(ownSentences(doc), HYPHEN_DASH), options.limit);
+/** A dash set as a character (an em dash, an en dash). */
+const TRUE_DASH = /[—–]/u;
+const DOUBLE_HYPHEN = "--";
+
+/**
+ * Whether the hit is a double hyphen in a document that sets no dash as a character: there "--" is how the document types its
+ * dash (plain-text standards, typewriter text, Markdown that a typographer turns into a dash), not a hyphen standing in for one.
+ */
+const isTypedDash = (hit: Hit, setsDashes: boolean): boolean => !setsDashes && hit.matched === DOUBLE_HYPHEN;
+
+export const hyphenDash: Detector = (doc, options): Finding[] => {
+  const sentences = ownSentences(doc);
+  const setsDashes = sentences.some((sentence) => TRUE_DASH.test(sentence.text));
+  return reportFrom(
+    hitsOf(sentences, HYPHEN_DASH).filter((hit) => !isTypedDash(hit, setsDashes)),
+    options.limit,
+  );
+};
 
 /** Every way of writing an abbreviation with some of its periods dropped but not all (e.g. → e.g, eg.). */
 export const partialForms = (abbreviation: string): string[] => {

package/src/detectors/nado-closed-list.ts

@@ -0,0 +1,25 @@
+// nado-closed-list: 等, など or etc. on a list a limit closes (自転車等に限ります, only A, B, etc.), read sentence by sentence
+// (nado-closed-list.ts). The tokens are moved to the sentence's own offsets before they are read.
+import { closedListWordsOf, openWordsOnClosedLists } from "../nado-closed-list.ts";
+import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
+
+const sentenceTokens = (sentence: Sentence): Token[] =>
+  (sentence.tokens ?? []).map((token) => ({
+    ...token,
+    span: { start: token.span.start - sentence.span.start, end: token.span.end - sentence.span.start },
+  }));
+
+export const nadoClosedList: Detector = (doc, options): Finding[] => {
+  const words = closedListWordsOf(options.lexicon ?? []);
+  if (words.open.length === 0) return [];
+  return doc.sentences.flatMap((sentence) =>
+    openWordsOnClosedLists(sentence.text, sentenceTokens(sentence), words).map((hit) => ({
+      rule: "",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { open: hit.open, limit: hit.limit, offset: sentence.span.start + hit.offset },
+    })),
+  );
+};

package/src/detectors/name-variant.ts

@@ -1,15 +1,118 @@
-import type { Detector, Finding } from "../plugin.ts";
-import { mentionsIn, nameVariants } from "../name-variants.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, type NameMention, type VariantChars } from "../name-variants.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 { placeMentionsIn, placeVariants, type PlaceReader, type PlaceWord } from "../place-names.ts";
+import type { Token } from "../plugin.ts";
+
+// 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
+// （です、まで）は name-particle、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
+
+const variantCharsOf = (doc: ProseDocument): VariantChars =>
+  new Map((doc.lexicons["name-variant-char"] ?? []).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）とともに言う。 */
+const companyFormsOf = (doc: ProseDocument): CompanyForm[] =>
+  (doc.lexicons["company-form"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern, position: entry.position }));
+
+/** source の上の範囲に、品詞解析が固有名詞と読んだ語が掛かるか。 */
+const properOf = (doc: ProseDocument): IsProper => {
+  const spans = doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).filter((token) => token.pos === "PROPN").map((token) => token.span));
+  return (start, end) => spans.some((span) => span.start < end && start < span.end);
+};
+
+/** 場所の名前の終わりに立つ語（口、駅、Street、St.）は語彙表 place-word が、同じ語の別の書き方の組（group）とともに言う。 */
+const placeWordsOf = (doc: ProseDocument): PlaceWord[] =>
+  (doc.lexicons["place-word"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+/** 名前の頭に立たない語の品詞（The、at、and）。 */
+const FUNCTION_POS: ReadonlySet<string> = new Set(["DET", "ADP", "PRON", "CCONJ", "SCONJ", "AUX", "PART"]);
+
+const tokensOf = (doc: ProseDocument): Token[] => doc.sentences.flatMap((sentence) => sentence.tokens ?? []);
+
+/** 場所の名前の語の数の上限。名前の読みを探す範囲。 */
+const MAX_PLACE_TOKENS = 20;
+
+/** 範囲をちょうど覆う語の読みをつないだもの。記号の語は読まない。覆えないか、読めない語があれば無い。 */
+const readingIn = (tokens: readonly Token[], startAt: ReadonlyMap<number, number>, start: number, end: number): string | undefined => {
+  const first = startAt.get(start);
+  if (first === undefined) return undefined;
+  const window = tokens.slice(first, first + MAX_PLACE_TOKENS);
+  const covering = window.slice(0, window.findIndex((token) => token.span.end >= end) + 1);
+  if (covering.at(-1)?.span.end !== end) return undefined;
+  const readings = covering.filter((token) => token.pos !== "PUNCT").map((token) => token.reading);
+  return readings.every((reading) => reading !== undefined && reading !== "") ? readings.join("") : undefined;
+};
+
+const placeReaderOf = (doc: ProseDocument): PlaceReader => {
+  const tokens = tokensOf(doc);
+  const startAt = new Map(tokens.map((token, index) => [token.span.start, index]));
+  const functionStarts = new Set(tokens.filter((token) => FUNCTION_POS.has(token.pos)).map((token) => token.span.start));
+  return {
+    properWords: (start, end) => {
+      const first = startAt.get(start);
+      const window = first === undefined ? [] : tokens.slice(first, first + MAX_PLACE_TOKENS);
+      return window.filter((token) => token.pos === "PROPN" && token.span.start < end).map((token) => token.span);
+    },
+    joiners: new Set(patternsOf(doc, "place-name-joiner")),
+    isFunctionWord: (start) => functionStarts.has(start),
+    readingOf: (start, end) => readingIn(tokens, startAt, start, end),
+  };
+};
+
+type Reported = { readonly offset: number; readonly name: string; readonly usual: string; readonly kind: string };
+
+const overlapsAny = (reported: readonly Reported[], offset: number, length: number): boolean =>
+  reported.some((other) => other.offset < offset + length && offset < other.offset + other.name.length);
+
+/** 会社の名前の書き分け。名前の見方がすでに指した所と重なるものは除く。 */
+const companyFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] =>
+  companyVariants(companyMentionsIn(prose, companyFormsOf(doc), properOf(doc)))
+    .filter(({ mention }) => !overlapsAny(reported, mention.offset, mention.surface.length))
+    .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind: kind === "spelling" ? kind : `company-${kind}` }));
+
+/** 場所の名前の書き分け。人や会社の名前の見方がすでに指した所と重なるものは除く。 */
+const placeFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] =>
+  placeVariants(placeMentionsIn(prose, placeWordsOf(doc), placeReaderOf(doc)))
+    .filter(({ mention }) => !overlapsAny(reported, mention.offset, mention.surface.length))
+    .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind }));
+
+/** 人・製品・会社の名前の現れ。解析器が固有名詞と読む語、敬称の付く名前、前後の語で名前と読める漢字。 */
+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 tagged = doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source, cues.suffixes));
+  const taggedOrSuffixed = [...tagged, ...suffixedNamesIn(prose, cues.suffixes, chars, tagged)];
+  return [...taggedOrSuffixed, ...cuedNamesIn(prose, cues, chars, taggedOrSuffixed)]
+    .map((mention): NameMention => {
+      const cue = mention.cue ?? nameCueAt(prose, mention.offset, mention.surface, cues);
+      return cue === undefined ? mention : { ...mention, cue };
+    })
+    .toSorted((left, right) => left.offset - right.offset);
+};
 
 /** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
-export const nameVariant: Detector = (doc): Finding[] =>
-  nameVariants(doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source))).map(({ mention, usual, kind }) => ({
-    rule: "",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAt(doc.source, mention.offset),
-    values: { name: mention.surface, usual, offset: mention.offset },
-    variant: kind,
+export const nameVariant: Detector = (doc): Finding[] => {
+  const prose = doc.prose ?? doc.source;
+  const chars = variantCharsOf(doc);
+  const names = nameVariants(nameMentionsOf(doc, prose, chars), chars).map(({ mention, usual, kind }): Reported => ({
+    offset: mention.offset,
+    name: mention.surface,
+    usual,
+    kind,
   }));
+  const namesAndCompanies = [...names, ...companyFindings(doc, prose, names)];
+  return [...namesAndCompanies, ...placeFindings(doc, prose, namesAndCompanies)]
+    .toSorted((left, right) => left.offset - right.offset)
+    .map(({ offset, name, usual, kind }) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, offset),
+      values: { name, usual, offset },
+      variant: kind,
+    }));
+};

package/src/detectors/next-word.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
 import { densityFindings } from "./ai-phrasing.ts";
+import { entryEndsAt } from "./lexicon-match.ts";
 
 /**
  * The word kinds an article can stand before. A conjunction, a preposition or a verb after "a" is the letter a ("option A
@@ -127,30 +128,76 @@ const ADJECTIVE = "ADJ";
 
 type Intensified = { readonly sentence: Sentence; readonly matched: string; readonly offset: number };
 
-type IntensifierWords = { readonly intensifiers: ReadonlySet<string>; readonly exceptions: ReadonlySet<string> };
+type IntensifierWords = {
+  readonly intensifiers: Lexicon;
+  readonly exceptions: ReadonlySet<string>;
+  /** Words after a noun that make it an adjective (便利な, 静かだ). Japanese only: its adjectival nouns are tagged as nouns. */
+  readonly copulas: ReadonlySet<string>;
+};
+
+/** An adjective, or a noun the lexicon's copula, an auxiliary (not the particle で), makes one: 便利 in 便利な. */
+const isAdjectiveAt = (tokens: readonly Token[], at: number, copulas: ReadonlySet<string>): boolean => {
+  const token = tokens[at];
+  if (token?.pos === ADJECTIVE) return true;
+  const after = tokens[at + 1];
+  return token?.pos === "NOUN" && after?.pos === "AUX" && copulas.has(after.surface);
+};
+
+const isBlank = (token: Token): boolean => token.surface.trim() === "";
+
+/** For each token, the index of the last non-blank token before it, or -1: one pass, so a long sentence is not rescanned per token. */
+const previousWords = (tokens: readonly Token[]): number[] =>
+  tokens.reduce<{ readonly before: number[]; readonly last: number }>(
+    ({ before, last }, token, index) => {
+      before.push(last);
+      return { before, last: isBlank(token) ? last : index };
+    },
+    { before: [], last: -1 },
+  ).before;
+
+/** The intensifier that ends at `end` (past a line break: 非常に / 危険), as the index of its first token. */
+const intensifierStart = (tokens: readonly Token[], end: number, intensifiers: Lexicon): number | undefined => {
+  const entry = intensifiers.find((candidate) => entryEndsAt(tokens, candidate, end));
+  return entry === undefined ? undefined : end - (entry.tokens?.length ?? 1);
+};
+
+/** The intensifier and the adjective as words: "very important" in a spaced language, 非常に危険 in one measured in characters. */
+const matchedText = (tokens: readonly Token[], start: number, at: number, spaced: boolean): string =>
+  tokens
+    .slice(start, at + 1)
+    .filter((token) => !isBlank(token))
+    .map((token) => token.surface)
+    .join(spaced ? " " : "");
 
 /** The lexicon's intensifier right before an adjective ("very important"), not before an excepted word ("the very first"). */
-const intensifiedIn = (source: string, sentence: Sentence, words: IntensifierWords): Intensified[] => {
+const intensifiedIn = (source: string, sentence: Sentence, words: IntensifierWords, spaced: boolean): Intensified[] => {
   const tokens = sentence.tokens ?? [];
-  return tokens.flatMap((token, at) => {
-    const next = tokens[at + 1];
-    if (next === undefined || !words.intensifiers.has(token.surface.toLowerCase()) || next.pos !== ADJECTIVE) return [];
-    if (!adjacent(source, token, next)) return [];
-    return words.exceptions.has(next.surface.toLowerCase()) ? [] : [{ sentence, matched: `${token.surface} ${next.surface}`, offset: token.span.start }];
+  const before = previousWords(tokens);
+  return tokens.flatMap((next, at) => {
+    const lastAt = before[at] ?? -1;
+    const start = intensifierStart(tokens, lastAt + 1, words.intensifiers);
+    const first = start === undefined ? undefined : tokens[start];
+    const last = tokens[lastAt];
+    if (start === undefined || first === undefined || last === undefined || !isAdjectiveAt(tokens, at, words.copulas)) return [];
+    if (!adjacent(source, last, next) || words.exceptions.has(next.surface.toLowerCase())) return [];
+    return [{ sentence, matched: matchedText(tokens, start, at, spaced), offset: first.span.start }];
   });
 };
 
 const EXCEPTIONS = "very-exception";
+const COPULAS = "very-copula";
 
 /** "very" + adjective, dense for the document's length: each one leans on "very" instead of a stronger word. */
 export const intensifiedAdjective: Detector = (doc, options): Finding[] => {
   const words = {
-    intensifiers: new Set((options.lexicon ?? []).map((entry) => entry.pattern)),
+    intensifiers: options.lexicon ?? [],
     exceptions: new Set((doc.lexicons[EXCEPTIONS] ?? []).map((entry) => entry.pattern)),
+    copulas: new Set((doc.lexicons[COPULAS] ?? []).map((entry) => entry.pattern)),
   };
+  const spaced = doc.lengthUnit !== "char";
   return densityFindings(
     doc,
-    doc.sentences.flatMap((sentence) => intensifiedIn(doc.source, sentence, words)),
+    doc.sentences.flatMap((sentence) => intensifiedIn(doc.source, sentence, words, spaced)),
     options.limit,
   );
 };