chaffjs 0.31.0 → 0.33.0

package/src/detectors/labelled-age.ts

@@ -0,0 +1,154 @@
+// An age beside a labelled date of birth, compared with the exact age on a labelled reference date (elapsed-years-mismatch).
+import type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { documentYearFindings } from "./derived-numbers.ts";
+import { calendarDateOf } from "../derived/date-arithmetic.ts";
+import {
+  ageMismatches,
+  ageVerdicts,
+  agesIn,
+  labelAfter,
+  labelBefore,
+  type AgeWords,
+  type LabelledBirth,
+  type LabelWord,
+  type LabelledReference,
+} from "../derived/age-on-date.ts";
+
+type DateNode = Span & { readonly value: string };
+
+const entriesOf = (doc: ProseDocument, id: string): readonly LexiconEntry[] => doc.lexicons[id] ?? [];
+
+const patternsAt = (doc: ProseDocument, id: string, position: "before" | "after"): string[] =>
+  entriesOf(doc, id)
+    .filter((entry) => (entry.position ?? "before") === position)
+    .map((entry) => entry.pattern);
+
+const ageWords = (doc: ProseDocument): AgeWords => ({
+  before: patternsAt(doc, "age-marker", "before"),
+  after: [...patternsAt(doc, "age-marker", "after"), ...entriesOf(doc, "age-unit").map((entry) => entry.pattern)],
+  skip: entriesOf(doc, "duration-year").map((entry) => entry.pattern),
+  approximateBefore: patternsAt(doc, "approximate-marker", "before"),
+  approximateAfter: patternsAt(doc, "approximate-marker", "after"),
+});
+
+const datesOf = (tree: StructureNode): DateNode[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+
+const lineStartOf = (source: string, at: number): number => source.lastIndexOf("\n", at - 1) + 1;
+
+const lineEndOf = (source: string, at: number): number => {
+  const end = source.indexOf("\n", at);
+  return end === -1 ? source.length : end;
+};
+
+const isFullDate = (value: string): boolean => calendarDateOf(value)?.year !== undefined;
+
+/** A clause or bracket ends here: past a reference date, the age is read only up to the first of these. */
+const CLAUSE_END = /[)）\]］】。;；]/u;
+
+const blanked = (text: string, from: number, spans: readonly Span[]): string =>
+  spans.reduce((written, span) => [written.slice(0, span.start - from), " ".repeat(span.end - span.start), written.slice(span.end - from)].join(""), text);
+
+type AgeRegion = { readonly text: string; readonly passed: readonly LabelledReference[] };
+
+const referenceAt = (references: readonly LabelledReference[], date: DateNode): LabelledReference | undefined =>
+  references.find((reference) => reference.start === date.start);
+
+/** The reference dates right after a date of birth on its line, before the first date that is not one. */
+const passedReferences = (later: readonly DateNode[], references: readonly LabelledReference[]): LabelledReference[] => {
+  const stop = later.findIndex((date) => referenceAt(references, date) === undefined);
+  return later.slice(0, stop === -1 ? later.length : stop).flatMap((date) => referenceAt(references, date) ?? []);
+};
+
+/** Where the age beside a date of birth is written: up to the next date that is not a reference date, or the line end.
+ * Past a reference date ("（2026年9月30日現在、23歳）"), only to the end of its bracket or clause; its digits are blanked. */
+const ageRegionOf = (doc: ProseDocument, date: DateNode, dates: readonly DateNode[], references: readonly LabelledReference[]): AgeRegion => {
+  const lineEnd = lineEndOf(doc.source, date.end);
+  const later = dates.filter((other) => other.start >= date.end && other.start < lineEnd);
+  const passed = passedReferences(later, references);
+  const last = passed.at(-1);
+  const open = later[passed.length]?.start ?? lineEnd;
+  const clauseEnd = last === undefined ? -1 : doc.source.slice(last.end, open).search(CLAUSE_END);
+  const end = last === undefined || clauseEnd === -1 ? open : last.end + clauseEnd;
+  return { text: blanked(doc.source.slice(date.end, end), date.end, passed), passed };
+};
+
+/** The age after a labelled date of birth, in its region (ageRegionOf): one age, or none. */
+const birthOf = (doc: ProseDocument, date: DateNode, dates: readonly DateNode[], references: readonly LabelledReference[]): LabelledBirth[] => {
+  if (
+    !isFullDate(date.value) ||
+    labelBefore(doc.source.slice(lineStartOf(doc.source, date.start), date.start), entriesOf(doc, "birth-date-label")) === undefined
+  )
+    return [];
+  const { text: region, passed } = ageRegionOf(doc, date, dates, references);
+  const ages = agesIn(region, ageWords(doc));
+  const [age] = ages;
+  if (ages.length !== 1 || age === undefined) return [];
+  const lead = region.slice(0, age.start).toLowerCase();
+  const tail = region.slice(age.end).trimStart().toLowerCase();
+  const mark = entriesOf(doc, "age-time-mark").find((entry) => lead.includes(entry.pattern.toLowerCase()) || tail.startsWith(entry.pattern.toLowerCase()));
+  const group = mark?.group ?? (passed.length === 1 ? passed[0]?.group : undefined);
+  return [{ start: date.start, end: date.end, birth: date.value, age: { ...age, start: date.end + age.start, end: date.end + age.end }, group }];
+};
+
+const ownLabel = (doc: ProseDocument, date: DateNode): LabelWord | undefined => {
+  const labels = entriesOf(doc, "age-reference-label");
+  return (
+    labelBefore(doc.source.slice(lineStartOf(doc.source, date.start), date.start), labels, ageWords(doc)) ??
+    labelAfter(doc.source.slice(date.end, lineEndOf(doc.source, date.end)), labels)
+  );
+};
+
+/** Dates with a reference label. A later date on the same line without a label of its own takes the label before it
+ * ("Examination date: March 1, 2026 and March 3, 2026" is two examination dates, and the age is then undecided). */
+const referencesOf = (doc: ProseDocument, dates: readonly DateNode[]): LabelledReference[] => {
+  const labelled = dates.reduce<{ readonly line: number; readonly label: LabelWord | undefined; readonly found: LabelledReference[] }>(
+    (state, date) => {
+      const line = lineStartOf(doc.source, date.start);
+      const label = ownLabel(doc, date) ?? (line === state.line ? state.label : undefined);
+      if (label !== undefined && isFullDate(date.value))
+        state.found.push({ start: date.start, end: date.end, date: date.value, group: label.group ?? label.pattern });
+      return { line, label, found: state.found };
+    },
+    { line: -1, label: undefined, found: [] },
+  );
+  return labelled.found;
+};
+
+const recordsOf = (doc: ProseDocument, tree: StructureNode): { births: LabelledBirth[]; references: LabelledReference[] } => {
+  const dates = datesOf(tree);
+  const references = referencesOf(doc, dates);
+  return { births: dates.flatMap((date) => birthOf(doc, date, dates, references)), references };
+};
+
+/** Where the ages whose reference date was decided start: the year-only check stays silent on them. */
+const decidedAgeStarts = (doc: ProseDocument, tree: StructureNode): ReadonlySet<number> => {
+  const { births, references } = recordsOf(doc, tree);
+  return new Set(ageVerdicts(births, references).map((verdict) => verdict.birth.age.start));
+};
+
+const written = (doc: ProseDocument, span: Span): string => doc.source.slice(span.start, span.end);
+
+const labelledAgeFindings = (doc: ProseDocument, tree: StructureNode): Finding[] => {
+  const { births, references } = recordsOf(doc, tree);
+  return ageMismatches(births, references).map(({ birth, reference, expected }) => ({
+    rule: "elapsed-years-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, birth.age.start),
+    variant: "birth-date",
+    values: { written: written(doc, birth.age), birth: written(doc, birth), reference: written(doc, reference), expected, offset: birth.age.start },
+  }));
+};
+
+/** 起点の年から数えた年数が文書の日付と合わない。生年月日の横の年齢が、受診日などの満年齢と合わない。 */
+export const elapsedYearsMismatch: Detector = (doc) => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const decided = decidedAgeStarts(doc, tree);
+  const byDocumentYear = documentYearFindings(doc, tree).filter((finding) => !decided.has(Number(finding.values?.["offset"])));
+  return [...labelledAgeFindings(doc, tree), ...byDocumentYear];
+};

package/src/detectors/line-amount.ts

@@ -1,10 +1,19 @@
 // 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.
+// unit-price-column, line-amount-column; pack-count-column and pack-price-column for a catalog's packs), the units from rate-unit, per-unit-mark and the measure lexicons (unit-volume, …); the tables are read from the prose with its tables put back, so code is not.
+// A product in an item cell's brackets is read with label-product-word, currency-notation and amount-multiplier.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { measureUnitsOf } from "../facts/measure-units.ts";
+import { quantityWordsOf } from "./order-quantity.ts";
 import { lineAmountMismatches, type LineAmountWords } from "../structure/line-amount.ts";
 import type { UnitWord } from "../structure/line-amount-unit.ts";
+import type { StructureIssue } from "../structure/issues.ts";
 import { proseAndTablesOf } from "../table-text.ts";
+import { labelProductMismatches, type LabelProductWords } from "../structure/line-amount-label.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+import { scaleWordsOf } from "./amount-scale.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { pointsMismatches, type PointsRole, type PointsWords } from "../structure/line-amount-rate.ts";
+import { linesOf } from "../structure/lines.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
@@ -19,11 +28,57 @@ const wordsOf = (doc: ProseDocument): LineAmountWords => ({
   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"),
+  headerUnits: unitWordsOf(doc, "quantity-column", "unit-price-column", "line-amount-column"),
+  measureUnits: measureUnitsOf(doc).flatMap((unit) => (unit.before ? [] : [unit.pattern])),
+  orderRoles: quantityWordsOf(doc).columns,
+  packCount: patternsOf(doc, "pack-count-column"),
+  packPrice: patternsOf(doc, "pack-price-column"),
+  itemName: patternsOf(doc, "item-name-column"),
+  taxIncluded: patternsOf(doc, "tax-included-word"),
 });
 
+const groupOf = (doc: ProseDocument, lexicon: string, group: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const labelWordsOf = (doc: ProseDocument): LabelProductWords => {
+  const [forms, scales] = [formsOf(doc), scaleWordsOf(doc).map((word) => word.word)];
+  return {
+    times: groupOf(doc, "label-product-word", "times"),
+    counts: groupOf(doc, "label-product-word", "count"),
+    isMoney: (text) => amountsIn(text, forms, scales).some((amount) => amount.written === text.trim()),
+  };
+};
+
+const POINTS_ROLES: readonly string[] = ["base", "rate", "earned"] satisfies readonly PointsRole[];
+const isPointsRole = (group: string | undefined): group is PointsRole => group !== undefined && POINTS_ROLES.includes(group);
+const HEADING = /^#{1,6}[ \t]/u;
+
+/** Lexicons points-earned-column (group base, rate or earned; a rate's weight is what a bare rate is per), points-unit, points-rate-joiner. */
+const pointsWordsOf = (doc: ProseDocument): PointsWords => ({
+  columns: (doc.lexicons["points-earned-column"] ?? []).flatMap((entry) =>
+    isPointsRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group, per: entry.weight }] : [],
+  ),
+  units: patternsOf(doc, "points-unit"),
+  joiners: patternsOf(doc, "points-rate-joiner"),
+});
+
+/** Where each heading of the source starts: the prose blanks headings, and a stated rate is read only in its table's section. */
+const headingStarts = (doc: ProseDocument): number[] =>
+  linesOf(doc.source)
+    .filter((line) => HEADING.test(line.text))
+    .map((line) => line.start);
+
+const mismatchesOf = (doc: ProseDocument): StructureIssue[] => {
+  const text = proseAndTablesOf(doc);
+  return [
+    ...lineAmountMismatches(text, wordsOf(doc)),
+    ...labelProductMismatches(text, labelWordsOf(doc)),
+    ...pointsMismatches(text, headingStarts(doc), pointsWordsOf(doc)),
+  ];
+};
+
 export const lineAmount: Detector = (doc): Finding[] =>
-  lineAmountMismatches(proseAndTablesOf(doc), wordsOf(doc)).map((issue) => ({
+  mismatchesOf(doc).map((issue) => ({
     rule: "line-amount-mismatch",
     severity: "error",
     line: 0,

package/src/detectors/measured-facts.ts

@@ -13,7 +13,7 @@ export const measuredOf = (doc: ProseDocument): Measured[] => {
 };
 
 /** fact-conflict の値に、単位の付いた量を足す。量と重なる値（量の数だけを読んだもの）は量に置き換える。 */
-export const valuesWith = (tree: StructureNode, doc: ProseDocument, measured: readonly Measured[]): FactValue[] => {
+export const valuesWith = (tree: StructureNode, doc: ProseDocument, measured: readonly FactValue[]): FactValue[] => {
   const taken = spanIndex(measured);
   const others = factValues(tree, doc.source, nameSpans(doc)).filter((value) => !overlapsAny(taken, value));
   return [...others, ...measured].toSorted((left, right) => left.start - right.start);

package/src/detectors/meter-usage.ts

@@ -0,0 +1,49 @@
+// meter-usage-mismatch: the reading half. The names of the readings come from the language's meter-reading-label lexicon,
+// the units from meter-unit, the stated rollover and meter replacement from meter-event; the readings are read from the
+// prose with its tables put back, so code is not, and the document's headings split it into sections.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { lineNumberAt, linesOf } from "../structure/lines.ts";
+import { meterUsageMismatches, type MeterKind, type MeterUnitWord, type MeterWords } from "../structure/meter-usage.ts";
+import { meterGroups, type MeterLabel } from "../structure/meter-usage-read.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const KINDS: ReadonlySet<string> = new Set(["current", "previous", "usage", "multiplier"]);
+
+const isKind = (group: string | undefined): group is MeterKind => group !== undefined && KINDS.has(group);
+
+const labelsOf = (doc: ProseDocument): MeterLabel[] =>
+  (doc.lexicons["meter-reading-label"] ?? []).flatMap((entry) => (isKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group }] : []));
+
+const unitsOf = (doc: ProseDocument): MeterUnitWord[] =>
+  (doc.lexicons["meter-unit"] ?? []).flatMap((entry) => (entry.group === undefined ? [] : [{ pattern: entry.pattern, unit: entry.group }]));
+
+const eventsOf = (doc: ProseDocument, group: string): string[] =>
+  (doc.lexicons["meter-event"] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const headingLinesOf = (doc: ProseDocument): number[] => {
+  const lines = linesOf(doc.source);
+  return (doc.markup?.headings ?? []).flatMap((heading) => lineNumberAt(lines, heading.start) ?? []);
+};
+
+export const meterUsage: Detector = (doc): Finding[] => {
+  const labels = labelsOf(doc);
+  if (labels.length === 0) return [];
+  const units = unitsOf(doc);
+  const words: MeterWords = {
+    units,
+    rollover: eventsOf(doc, "rollover"),
+    rolloverNegationAfter: eventsOf(doc, "rollover-negation-after"),
+    rolloverNegationBefore: eventsOf(doc, "rollover-negation-before"),
+    replaced: eventsOf(doc, "replaced"),
+  };
+  const groups = meterGroups(proseAndTablesOf(doc), headingLinesOf(doc), { labels, units });
+  return meterUsageMismatches(groups, words).map((issue) => ({
+    rule: "meter-usage-mismatch",
+    severity: "error",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/name-field.ts

@@ -0,0 +1,43 @@
+/** How many characters a line may add to the long name and still be a line that only names the party. */
+export const SLACK = 12;
+
+/** A field label on its own line, after a list marker (Attention:, 宛先：): short, and not a sentence. */
+const FIELD_LABEL = /^(?:[-*+]\s+)?[^:：。.]{1,20}[:：]\s*/u;
+/**
+ * What may follow the name in an address field: nothing, a comma and the next part (, Member Support), or a space and a part
+ * that does not go on in lower case (株式会社みなと 総務部). A particle or a verb (は支払う, shall pay) makes the line a sentence.
+ */
+const NEXT_PART = /^\.?(?:$|\s*[,、，]|\s+(?!\p{Ll}))/u;
+export const CLOSES_SENTENCE = /[.。!?！？]$/u;
+
+/** A field whose value is the name and a little more, not a sentence (Attention: Hibari Lab Inc., Member Support). */
+export const isNameField = (line: string, name: string): boolean => {
+  const label = FIELD_LABEL.exec(line);
+  const value = label === null ? "" : line.slice(label[0].length);
+  const rest = value.slice(name.length);
+  return value.startsWith(name) && NEXT_PART.test(rest) && [...rest].length <= SLACK * 2 && !CLOSES_SENTENCE.test(rest.slice(1));
+};
+
+/**
+ * After the name on a signature line, the parts of an address: each after a comma or a space, none in lower case, and no
+ * 、 (Hibari Lab Inc., Customer Support; 株式会社みなと 総務部). A lower-case word or a 、 goes on as a sentence (, as Supplier, shall pay).
+ */
+const ADDRESS_PARTS = /^\.?(?:,?\s+[^\s,、，\p{Ll}][^\s,、，]*)*$/u;
+
+/** A line with no label that is the name and the parts of an address: a signature (Hibari Lab Inc., Customer Support). */
+export const isSignatureLine = (line: string, name: string): boolean => {
+  const rest = line.slice(name.length);
+  return line.startsWith(name) && [...rest].length <= SLACK * 2 && ADDRESS_PARTS.test(rest);
+};
+
+const linesOf = (text: string): string[] => text.split(/\r?\n/u).map((line) => line.trim());
+
+/**
+ * The line from lineStart to lineEnd opens the closing block: a blank line (or nothing) before it, and no sentence after it to
+ * the end (a phone number, an address).
+ */
+export const opensClosingBlock = (source: string, lineStart: number, lineEnd: number): boolean => {
+  const before = linesOf(source.slice(0, lineStart)).slice(0, -1);
+  const after = linesOf(source.slice(lineEnd));
+  return (before.length === 0 || before.at(-1) === "") && after.every((line) => !CLOSES_SENTENCE.test(line));
+};

package/src/detectors/name-variant.ts

@@ -1,16 +1,26 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, withKnownNeighbours, type NameMention, type VariantChars } from "../name-variants.ts";
+import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, type NameMention, type VariantChars } from "../name-variants.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 { 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 { kanaSpelledCompanies, type ReadWord } from "../company-kana-spelling.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { tableBodyCells } from "../facts/table-facts.ts";
 import { cellNamesIn, cellNameVariants, proseNamesOf } from "../table-names.ts";
 import { placeMentionsIn, placeVariants, type PlaceChars, type PlaceReader, type PlaceWord } from "../place-names.ts";
-import type { TableCell, Token } from "../plugin.ts";
+import { productMentionsIn, productVariants, type ProductForm } from "../product-names.ts";
+import type { Sentence, Span, TableCell, Token } from "../plugin.ts";
+import { isLineBlock, tokensByLine } from "../name-line-block.ts";
 import { proseWithCells } from "../table-cells.ts";
 import { modelCodeFindings } from "./name-variant-model-codes.ts";
+import { fullNameGaps, joinFullNames, spacedOnly } from "../person-full-name.ts";
+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";
 
 // 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
@@ -19,12 +29,25 @@ import { labelledSpans, orderNamesOf, quotedSpans, stemOf, titleCaseSpans, wordO
 const variantCharsOf = (doc: ProseDocument): VariantChars =>
   new Map((doc.lexicons["name-variant-char"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
 
+/** 解析器が読めない名前の字（汰）の読みは、語彙表 name-char-reading が組（group）に言う。 */
+const charReadingsOf = (doc: ProseDocument): CharReadings =>
+  new Map((doc.lexicons["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）とともに言う。 */
 const companyFormsOf = (doc: ProseDocument): CompanyForm[] =>
   (doc.lexicons["company-form"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern, position: entry.position }));
 
+/** カタカナか英字の名前のすぐ後ろにだけ立つ形の語（社）と、その語で始まる漢字の語（社員）は、語彙表 company-form-foreign が言う。 */
+const foreignFormsOf = (doc: ProseDocument): CompanyForm[] => {
+  const entries = doc.lexicons["company-form-foreign"] ?? [];
+  const words = entries.filter((entry) => entry.group === "word").map((entry) => entry.pattern);
+  return entries
+    .filter((entry) => entry.group === "form")
+    .map((entry) => ({ pattern: entry.pattern, group: entry.pattern, position: "after", foreign: { words } }));
+};
+
 /** source の上の範囲に、品詞解析が固有名詞と読んだ語が掛かるか。 */
 const properOf = (doc: ProseDocument): IsProper => {
   const spans = doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).filter((token) => token.pos === "PROPN").map((token) => token.span));
@@ -94,11 +117,34 @@ type Reported = { readonly offset: number; readonly name: string; readonly usual
 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}` }));
+/** 会社の名前の頭のひらがなを切り分ける語は、語彙表 company-name-kana が組（particle、opener、end）ごとに言う。 */
+const kanaStopsOf = (doc: ProseDocument): Parameters<typeof companyMentionsIn>[3] => {
+  const entries = doc.lexicons["company-name-kana"] ?? [];
+  const inGroup = (group: string): string[] => entries.filter((entry) => entry.group === group).map((entry) => entry.pattern);
+  return { particles: inGroup("particle"), openers: inGroup("opener"), ends: inGroup("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 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 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)
+    .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));
+};
 
 /** 場所の名前の書き分け。表の本体の升の中の名前も読む（見出しの行は読まない）。人や会社の名前の見方がすでに指した所と重なるものは除く。 */
 const placeFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[], chars: VariantChars): Reported[] =>
@@ -106,6 +152,23 @@ const placeFindings = (doc: ProseDocument, prose: string, reported: readonly Rep
     .filter(({ mention }) => !overlapsAny(reported, mention.offset, mention.surface.length))
     .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind }));
 
+/** 製品の形の語（錠、カプセル、クリーム）は語彙表 product-form が、同じ形の別の書き方の組（group）とともに言う。 */
+const productFormsOf = (doc: ProseDocument): ProductForm[] =>
+  (doc.lexicons["product-form"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+/** 見出しの文字の範囲。本文（prose）は見出しを覆う。 */
+const headingTextsOf = (doc: ProseDocument): (Span & { readonly text: string })[] =>
+  (doc.markup?.headings ?? []).flatMap((heading) => {
+    const start = doc.source.indexOf(heading.text, heading.start);
+    return start < 0 || start + heading.text.length > heading.end ? [] : [{ start, end: start + heading.text.length, text: heading.text }];
+  });
+
+/** 製品の名前の書き損じ。題や見出し（ミナモール錠 添付文書）と表の本体の升の中の名前も読む。ほかの見方がすでに指した所と重なるものは除く。 */
+const productFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] =>
+  productVariants(productMentionsIn(proseWithCells(prose, [...cellsOf(doc), ...headingTextsOf(doc)]), productFormsOf(doc)))
+    .filter(({ mention }) => !overlapsAny(reported, mention.offset, mention.surface.length))
+    .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind }));
+
 /** 名前の中で比べる語の品詞。助詞や冠詞（の、of）は語の順に数えない。 */
 const CONTENT_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN", "ADJ", "NUM", "VERB"]);
 
@@ -144,18 +207,67 @@ const orderFindings = (doc: ProseDocument, prose: string, reported: readonly Rep
     .map(({ name, usual }) => ({ offset: name.offset, name: name.surface, usual, kind: "order" }));
 };
 
-/** 人・製品・会社の名前の現れ。解析器が固有名詞と読む語、敬称の付く名前、前後の語で名前と読める漢字。 */
+const BLANK = /^\s*$/u;
+
+/** 範囲をちょうど覆う、空白でない語。範囲の端が語の途中なら無い。 */
+const wordsCovering = (tokens: readonly Token[], startAt: ReadonlyMap<number, number>, span: Span): Token[] | undefined => {
+  const first = startAt.get(span.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 >= span.end) + 1);
+  return covering.at(-1)?.span.end === span.end ? covering.filter((token) => !BLANK.test(token.surface)) : undefined;
+};
+
+/**
+ * 空白を挟んだ姓と名で、敬称か肩書きが付くか、人を書く欄にあるもの（高瀬 誠部長、氏名：森川 大輔）。語は解析器の切り方のまま、
+ * 読みは語の読みをつなぐ。解析器の語の切れ目と姓・名の端が合わないものは読まない。
+ */
+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]));
+  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" },
+    ];
+  });
+};
+
+/** 文の語。短い行を 1 行に 1 つずつ並べた文（署名、住所）は行ごと。名前を次の行の語まで伸ばして読まないため。 */
+const tokenRunsOf = (sentence: Sentence): readonly (readonly Token[])[] => {
+  const tokens = sentence.tokens ?? [];
+  return isLineBlock(sentence.text) ? tokensByLine(tokens, sentence.text, sentence.span.start) : [tokens];
+};
+
+/** 人・製品・会社の名前の現れ。解析器が固有名詞と読む語、敬称の付く名前、前後の語で名前と読める漢字。空白を挟んだ姓と名は一つ。 */
 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 charReadings = charReadingsOf(doc);
+  const tagged = doc.sentences.flatMap((sentence) => tokenRunsOf(sentence).flatMap((tokens) => mentionsIn(tokens, doc.source, 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);
     return cue === undefined ? mention : { ...mention, cue };
   });
-  return withKnownNeighbours(cued, prose).toSorted((left, right) => left.offset - right.offset);
+  const joined = joinFullNames(cued, fullNameGaps(tokensOf(doc), cues.suffixes));
+  const spaced = spacedNameMentionsOf(doc, prose, charReadings);
+  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);
 };
 
+/** 人の名前で形の似た別の字（太 と 大）は語彙表 name-lookalike-char が組（group）ごとに言う。 */
+const lookalikeCharsOf = (doc: ProseDocument): LookalikeChars =>
+  new Map(
+    (doc.lexicons["name-lookalike-char"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])),
+  );
+
 /** 一語の名前の中で同じ音を書く字（ヶ・ケ・が）は語彙表 name-spelling-char が組（group）ごとに言う。 */
 const spellingCharsOf = (doc: ProseDocument): VariantChars =>
   new Map((doc.lexicons["name-spelling-char"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
@@ -168,25 +280,57 @@ const spellingInputOf = (doc: ProseDocument): SpellingInput => {
 
 /** 表の升に書いた名前の書き分け。名前の形をした升を、本文の名前と比べる。ほかの見方がすでに指した所と重なるものは除く。 */
 const tableFindings = (doc: ProseDocument, prose: string, mentions: readonly NameMention[], reported: readonly Reported[]): Reported[] =>
-  cellNameVariants(cellNamesIn(cellsOf(doc)), proseNamesOf(mentions, prose))
+  cellNameVariants(cellNamesIn(cellsOf(doc), charReadingsOf(doc)), proseNamesOf(mentions, prose))
     .filter(({ name }) => !reported.some((other) => other.offset < name.offset + name.surface.length && name.offset < other.offset + other.name.length))
     .map(({ name, usual, kind }) => ({ offset: name.offset, name: name.surface, usual, kind }));
 
+/** 日本語の人の名前の、姓と名のあいだの空白だけの違い（田中 裕子 と 田中裕子）は書き分けとして指さない。 */
+const notSpacingOnly = ({ name, usual, kind }: Reported): boolean => kind !== "spelling" || !spacedOnly(name, usual);
+
+/**
+ * ふつうの語でもある一語の名前に印を付ける。敬称（Mr.）や肩書き（Senator）の後ろに書いた語は、表や見出しの中でも人の名前に使っている。
+ * 人を書く欄（Customer:、語彙表 person-label）の後ろの名前の姓も同じ。
+ */
+const ordinaryNamesOf = (doc: ProseDocument, mentions: readonly NameMention[]): NameMention[] => {
+  const ordinaryStarts = new Set(tokensOf(doc).flatMap((token) => (isOrdinaryToken(token) ? [token.span.start] : [])));
+  return withOrdinaryWords(
+    mentions,
+    ordinaryStarts,
+    doc.source,
+    [...patternsOf(doc, "honorific"), ...patternsOf(doc, "name-title")],
+    patternsOf(doc, "person-label"),
+  );
+};
+
+/** 人を書く欄（語彙表 person-label）に書いた名前に印を付ける。一度ずつ書いた二つの形のうち、欄の形を正しい形と見る。 */
+const labelledNamesOf = (doc: ProseDocument, mentions: readonly NameMention[]): NameMention[] => {
+  const labels = patternsOf(doc, "person-label");
+  const suffixes = patternsOf(doc, "person-suffix");
+  return mentions.map((mention) =>
+    isInPersonField(doc.source, mention.offset, mention.surface.length, labels, suffixes) ? { ...mention, labelled: true } : mention,
+  );
+};
+
 /** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
 export const nameVariant: Detector = (doc): Finding[] => {
   const prose = doc.prose ?? doc.source;
   const chars = variantCharsOf(doc);
-  const mentions = nameMentionsOf(doc, prose, chars);
-  const names = nameVariants(mentions, chars, spellingInputOf(doc)).map(({ mention, usual, kind }): Reported => ({
+  const mentions = labelledNamesOf(doc, ordinaryNamesOf(doc, nameMentionsOf(doc, prose, chars)));
+  const variants = nameVariants(mentions, chars, spellingInputOf(doc))
+    .map(({ mention, usual, kind }): Reported => ({ offset: mention.offset, name: mention.surface, usual, kind }))
+    .filter(notSpacingOnly);
+  const lookalikes = lookalikeSlipsIn(mentions, lookalikeCharsOf(doc)).map(({ mention, usual }) => ({
     offset: mention.offset,
     name: mention.surface,
     usual,
-    kind,
+    kind: "lookalike",
   }));
+  const names = [...variants, ...lookalikes.filter((found) => !overlapsAny(variants, found.offset, found.name.length))];
   const namesAndCompanies = [...names, ...companyFindings(doc, prose, names)];
-  const withTables = [...namesAndCompanies, ...tableFindings(doc, prose, mentions, namesAndCompanies)];
+  const withTables = [...namesAndCompanies, ...tableFindings(doc, prose, mentions, namesAndCompanies).filter(notSpacingOnly)];
   const withPlaces = [...withTables, ...placeFindings(doc, prose, withTables, chars)];
-  const withOrder = [...withPlaces, ...orderFindings(doc, prose, withPlaces)];
+  const withProducts = [...withPlaces, ...productFindings(doc, prose, withPlaces)];
+  const withOrder = [...withProducts, ...orderFindings(doc, prose, withProducts)];
   const codes = modelCodeFindings(doc, prose).filter((code) => !overlapsAny(withOrder, code.offset, code.name.length));
   return [...withOrder, ...codes]
     .toSorted((left, right) => left.offset - right.offset)