chaffjs 0.31.0 → 0.32.0

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)

package/src/detectors/net-amount-mismatch.ts

@@ -0,0 +1,86 @@
+// net-amount-mismatch: the reading half. Reads each table (its header cells and the cells of its rows) and each section's
+// lines that are a label and an amount (総支給額：117,380円), with the words of lexicon net-amount-label, and leaves the
+// deciding to structure/net-amount.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { sectionNetMismatch, tableNetMismatches, type LabelledLine, type NetCell, type NetIssue, type NetWords } from "../structure/net-amount.ts";
+
+const RULE = "net-amount-mismatch";
+const HEADING = /^#{1,6}[ \t]/u;
+/** A line that is a label and an amount, after any list marker: "- 総支給額：117,380円", "Net pay: $1,396.41". */
+const LIST_MARKER = /^[ \t]*(?:[-*+]|\d{1,3}[.)])?[ \t]*/u;
+const COLON = /[:：]/u;
+const MAX_LABEL = 40;
+
+export const patternsOf = (doc: ProseDocument, id: string, group?: string): string[] =>
+  (doc.lexicons[id] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): NetWords => ({
+  labels: {
+    gross: patternsOf(doc, "net-amount-label", "gross"),
+    deduction: patternsOf(doc, "net-amount-label", "deduction"),
+    "deduction-part": patternsOf(doc, "net-amount-label", "deduction-part"),
+    net: patternsOf(doc, "net-amount-label", "net"),
+    taxable: patternsOf(doc, "net-amount-label", "taxable"),
+  },
+  periods: (doc.lexicons["net-amount-period"] ?? []).filter((entry) => entry.position !== undefined),
+  periodLabels: { gross: patternsOf(doc, "net-amount-period", "gross") },
+  magnitudes: patternsOf(doc, "amount-multiplier"),
+  percentUnits: patternsOf(doc, "percent-unit"),
+});
+
+export const plainCellsOf = (line: Line): NetCell[] =>
+  cellsOf(line).map((cell) => {
+    const text = withoutEdgeMarks(cell.text);
+    return { start: cell.start + Math.max(0, cell.text.indexOf(text)), text };
+  });
+
+const tableIssues = (lines: readonly Line[], words: NetWords): NetIssue[] =>
+  tablesOf(lines).flatMap((table) => tableNetMismatches(plainCellsOf(table.header), table.rows.map(plainCellsOf), words));
+
+export const labelledLineOf = (line: Line): LabelledLine[] => {
+  const colon = COLON.exec(line.text)?.index;
+  if (colon === undefined) return [];
+  const label = withoutEdgeMarks(line.text.slice(LIST_MARKER.exec(line.text)?.[0].length ?? 0, colon));
+  const value = line.text.slice(colon + 1);
+  const text = withoutEdgeMarks(value);
+  if (label === "" || label.length > MAX_LABEL || text === "") return [];
+  return [{ label, value: { start: line.start + colon + 1 + value.indexOf(text), text } }];
+};
+
+/** The lines of the text between headings (the headings are read in the source: the prose text blanks them). */
+export const sectionsOf = (lines: readonly Line[], sourceLines: readonly Line[]): Line[][] =>
+  lines.reduce<Line[][]>(
+    (sections, line, index) => {
+      if (HEADING.test(sourceLines[index]?.text ?? "")) return [...sections, []];
+      sections.at(-1)?.push(line);
+      return sections;
+    },
+    [[]],
+  );
+
+const sectionIssues = (lines: readonly Line[], source: string, words: NetWords): NetIssue[] =>
+  sectionsOf(lines, linesOf(source)).flatMap((section) => {
+    const issue = sectionNetMismatch(section.filter((line) => !line.text.includes("|")).flatMap(labelledLineOf), words);
+    return issue === undefined ? [] : [issue];
+  });
+
+export const netAmountMismatch: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.labels.gross.length === 0 || words.labels.deduction.length + words.labels["deduction-part"].length === 0) return [];
+  const lines = linesOf(proseAndTablesOf(doc));
+  return [...tableIssues(lines, words), ...sectionIssues(lines, doc.source, words)]
+    .toSorted((left, right) => left.offset - right.offset)
+    .map((issue) => ({
+      rule: RULE,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+};

package/src/detectors/net-gross-weight.ts

@@ -0,0 +1,39 @@
+// net-over-gross: the reading half. Reads the document's Markdown tables, the lexicon net-gross-weight-column and the
+// mass units of unit-mass, and leaves the deciding to structure/net-gross-weight.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { netOverGross, type WeightRole, type WeightWords } from "../structure/net-gross-weight.ts";
+
+const RULE = "net-over-gross";
+const ROLES: readonly string[] = ["net", "gross"] satisfies readonly WeightRole[];
+const isRole = (group: string | undefined): group is WeightRole => group !== undefined && ROLES.includes(group);
+
+/**
+ * Lexicon net-gross-weight-column: the heading words that say which column holds the net and the gross weight, and (group
+ * qualifier) the words after a number that make it no exact weight. Lexicon unit-mass: the factor of each mass unit.
+ */
+const weightWordsOf = (doc: ProseDocument): WeightWords => {
+  const entries = doc.lexicons["net-gross-weight-column"] ?? [];
+  return {
+    columns: entries.flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : [])),
+    qualifiers: entries.flatMap((entry) => (entry.group === "qualifier" ? [entry.pattern] : [])),
+    units: (doc.lexicons["unit-mass"] ?? []).flatMap((entry) => (entry.weight === undefined ? [] : [{ pattern: entry.pattern, factor: entry.weight }])),
+  };
+};
+
+export const netOverGrossDetector: Detector = (doc): Finding[] => {
+  const words = weightWordsOf(doc);
+  if (words.columns.length === 0) return [];
+  const tables = tablesOf(linesOf(proseAndTablesOf(doc))).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+  return netOverGross(tables, words).map((issue) => ({
+    rule: RULE,
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/nominal-step.ts

@@ -0,0 +1,35 @@
+import type { Token } from "../plugin.ts";
+
+/**
+ * A numbered item that names something instead of telling the reader to do something: a list of cases (exclusions, causes,
+ * conditions), not a procedure. The tagger reads an imperative at the head of a step as a noun (Click, Press), so the
+ * part of speech alone does not tell them apart; the form does.
+ */
+const SKIPPED = new Set(["PUNCT", "NUM", "SYM", "X", "SPACE"]);
+const NOUN_PHRASE_PART = new Set(["NOUN", "PROPN", "CCONJ"]);
+const NOMINAL = new Set(["NOUN", "PROPN"]);
+
+/** An imperative is the verb's base form. A head in another form (Faults, Repairs, Uses) is a plural noun or a third-person verb. */
+const isInflectedHead = (head: Token): boolean => head.lemma !== undefined && head.lemma !== "" && head.surface.toLowerCase() !== head.lemma.toLowerCase();
+
+/** A participle in its own form (caused, made), not a base form the tagger marked (Set). */
+const isPastParticiple = (token: Token | undefined): boolean => token?.pos === "VERB" && token.features?.["VerbForm"] === "Part" && isInflectedHead(token);
+
+/** Nouns joined by a conjunction (Faults or damage). Two nouns side by side may be an imperative and its object (Access files). */
+const isJoinedNouns = (words: readonly Token[]): boolean =>
+  words.length % 2 === 1 && words.every((token, at) => (at % 2 === 0 ? NOMINAL.has(token.pos) : token.pos === "CCONJ"));
+
+/**
+ * A noun, then a participle and a preposition (Damage caused by a drop, Loss incurred during shipping): the participle
+ * describes the noun. An imperative's object comes after the verb (Copy saved files, Access files saved in a folder).
+ */
+const opensWithReducedClause = (words: readonly Token[]): boolean => {
+  const participleAt = words.findIndex((token) => !NOUN_PHRASE_PART.has(token.pos));
+  return participleAt > 0 && isJoinedNouns(words.slice(0, participleAt)) && isPastParticiple(words[participleAt]) && words[participleAt + 1]?.pos === "ADP";
+};
+
+export const opensAsNounPhrase = (tokens: readonly Token[]): boolean => {
+  const words = tokens.filter((token) => !SKIPPED.has(token.pos));
+  const head = words[0];
+  return head !== undefined && (isInflectedHead(head) || opensWithReducedClause(words));
+};