chaffjs 0.30.0 → 0.32.0

package/src/detectors/name-variant-model-codes.ts

@@ -0,0 +1,27 @@
+import type { MarkupHeading, ProseDocument } from "../plugin.ts";
+import { codesAfterLabels, codesInTitle, modelCodeVariants } from "../model-codes.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { tableBodyCells } from "../facts/table-facts.ts";
+import { proseWithCells } from "../table-cells.ts";
+
+// 型番の欄の語（型番、Model No.）は語彙表 model-code-label が言う。
+
+type ModelCodeFinding = { readonly offset: number; readonly name: string; readonly usual: string; readonly kind: string };
+
+/** 文書の題: 一番浅い見出しのうち最初のもの。 */
+const titleOf = (doc: ProseDocument): MarkupHeading | undefined => {
+  const headings = doc.markup?.headings ?? [];
+  const top = Math.min(...headings.map((heading) => heading.depth));
+  return headings.find((heading) => heading.depth === top);
+};
+
+/** 題か型番の欄に書いた型番を、ほかの所（題・表の升も）で別の形に書いた所。prose は見出しと表を覆うので、題と升の字を書き戻して読む。 */
+export const modelCodeFindings = (doc: ProseDocument, prose: string): ModelCodeFinding[] => {
+  const title = titleOf(doc);
+  const titleSpans = title === undefined ? [] : [{ start: title.start, end: title.end, text: doc.source.slice(title.start, title.end) }];
+  const text = proseWithCells(prose, [...titleSpans, ...(doc.tableCells?.() ?? tableBodyCells(proseAndTablesOf(doc)))]);
+  const labels = (doc.lexicons["model-code-label"] ?? []).map((entry) => entry.pattern);
+  const titleCodes = title === undefined ? [] : codesInTitle(text, title.start, title.end);
+  const anchors = [...titleCodes, ...codesAfterLabels(text, labels)].toSorted((left, right) => left.offset - right.offset);
+  return modelCodeVariants(text, anchors).map(({ code, usual }) => ({ offset: code.offset, name: code.surface, usual, kind: "model-code" }));
+};

package/src/detectors/name-variant.ts

@@ -1,14 +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 PlaceReader, type PlaceWord } from "../place-names.ts";
-import type { TableCell, Token } from "../plugin.ts";
+import { placeMentionsIn, placeVariants, type PlaceChars, type PlaceReader, type PlaceWord } from "../place-names.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、名前のすぐ後ろに来る語
@@ -17,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));
@@ -33,6 +58,18 @@ const properOf = (doc: ProseDocument): IsProper => {
 const placeWordsOf = (doc: ProseDocument): PlaceWord[] =>
   (doc.lexicons["place-word"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
 
+/**
+ * 場所の名前の字。方角や位置の字（東、上、新）は語彙表 place-direction、読みの同じ字（洲 と 州）は place-name-char と、字体の違う
+ * 同じ字の name-variant-char が組（group）ごとに言う。
+ */
+const placeCharsOf = (doc: ProseDocument, chars: VariantChars): PlaceChars => ({
+  directions: new Set(patternsOf(doc, "place-direction")),
+  sameReading: new Map([
+    ...chars,
+    ...(doc.lexicons["place-name-char"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])),
+  ]),
+});
+
 /** 名前の頭に立たない語の品詞（The、at、and）。 */
 const FUNCTION_POS: ReadonlySet<string> = new Set(["DET", "ADP", "PRON", "CCONJ", "SCONJ", "AUX", "PART"]);
 
@@ -80,15 +117,55 @@ 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[]): Reported[] =>
-  placeVariants(placeMentionsIn(proseWithCells(prose, cellsOf(doc)), placeWordsOf(doc), placeReaderOf(doc)))
+const placeFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[], chars: VariantChars): Reported[] =>
+  placeVariants(placeMentionsIn(proseWithCells(prose, cellsOf(doc)), placeWordsOf(doc), placeReaderOf(doc)), placeCharsOf(doc, chars))
+    .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 }));
 
@@ -130,39 +207,132 @@ 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]])));
+
+/** 名前の中の同じ音の字は、表の升の中の、解析器が固有名詞と読む語（物件名の升の 桜ケ丘）とも比べる。 */
+const spellingInputOf = (doc: ProseDocument): SpellingInput => {
+  const suffixes = patternsOf(doc, "person-suffix");
+  return { chars: spellingCharsOf(doc), alsoWritten: cellsOf(doc).flatMap((cell) => mentionsIn(cell.tokens ?? [], doc.source, suffixes)) };
 };
 
 /** 表の升に書いた名前の書き分け。名前の形をした升を、本文の名前と比べる。ほかの見方がすでに指した所と重なるものは除く。 */
 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).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 withPlaces = [...withTables, ...placeFindings(doc, prose, withTables)];
-  return [...withPlaces, ...orderFindings(doc, prose, withPlaces)]
+  const withTables = [...namesAndCompanies, ...tableFindings(doc, prose, mentions, namesAndCompanies).filter(notSpacingOnly)];
+  const withPlaces = [...withTables, ...placeFindings(doc, prose, withTables, chars)];
+  const withProducts = [...withPlaces, ...productFindings(doc, prose, withPlaces)];
+  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)
     .map(({ offset, name, usual, kind }) => ({
       rule: "",

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

package/src/detectors/number-style.ts

@@ -19,6 +19,8 @@ export type NumberWords = {
   readonly countWords: readonly string[];
   /** Plural nouns of measure (days, miles) that take figures in every style: a number before one is not a count. */
   readonly figureNouns: readonly string[];
+  /** Words written before a number to name one of a series (Grade 5, Room 12): the number after one is not a count. */
+  readonly nameWords: readonly string[];
 };
 
 const alternation = (words: readonly string[]): string =>
@@ -147,9 +149,14 @@ const valueOf = (surface: string, words: readonly string[]): number | undefined
 const isCountedNoun = (token: Token | undefined, figureNouns: readonly string[]): boolean =>
   token?.pos === "NOUN" && token.features?.["Number"] === "Plur" && !figureNouns.includes(token.surface.toLowerCase());
 
+/** Whether the text ends in one of the name words, standing as a word of its own (Grade 5, No. 5). */
+const endsInNameWord = (before: string, nameWords: readonly string[]): boolean =>
+  nameWords.length > 0 && new RegExp(`(?<![\\p{L}\\p{N}])(?:${alternation(nameWords)})\\s*$`, "u").test(before);
+
 /**
  * A number before a plural noun (three files, 3 files), from two to the last number word the language lists. One is a
- * pronoun as often as a count. A number word that opens the sentence is spelt out by every style, so it is not counted.
+ * pronoun as often as a count. A number word that opens the sentence is spelt out by every style, so it is not counted,
+ * nor a number after a name word (Grade 5 students), which names the group rather than counting it.
  */
 const englishCountMarks = (sentence: Sentence, words: NumberWords): NumberMark[] => {
   const tokens = sentence.tokens ?? [];
@@ -157,8 +164,9 @@ const englishCountMarks = (sentence: Sentence, words: NumberWords): NumberMark[]
     const value = valueOf(token.surface, words.countWords);
     if (value === undefined || value < SMALL_FROM || value > words.countWords.length || index === 0 || !isCountedNoun(tokens[index + 1], words.figureNouns))
       return [];
+    if (endsInNameWord(sentence.text.slice(0, token.span.start - sentence.span.start), words.nameWords)) return [];
     const style = /^\d+$/u.test(token.surface) ? "digits" : "words";
-    return [{ kind: value < LARGE_FROM ? "count-small" : "count-large", style, written: token.surface, offset: sentence.span.start + token.span.start }];
+    return [{ kind: value < LARGE_FROM ? "count-small" : "count-large", style, written: token.surface, offset: token.span.start }];
   });
 };
 
@@ -201,6 +209,7 @@ const wordsOf = (doc: ProseDocument): NumberWords => {
     percentUnits: patterns("percent-unit"),
     countWords: patterns("count-number"),
     figureNouns: patterns("figure-noun"),
+    nameWords: patterns("number-name-word"),
   };
 };
 

package/src/detectors/order-quantity.ts

@@ -0,0 +1,46 @@
+// delivered-over-ordered and backorder-mismatch: the reading half. Reads the document's Markdown tables and the lexicon
+// order-quantity-column, and leaves the deciding to structure/order-quantity.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 type { ChangeTable } from "../structure/change-rate-table.ts";
+import type { StructureIssue } from "../structure/issues.ts";
+import { backorderMismatches, deliveredOverOrdered, type QuantityRole, type QuantityWords } from "../structure/order-quantity.ts";
+
+const ROLES: readonly string[] = ["ordered", "delivered", "backordered"] satisfies readonly QuantityRole[];
+const isRole = (group: string | undefined): group is QuantityRole => group !== undefined && ROLES.includes(group);
+
+/**
+ * Lexicon order-quantity-column: the heading words that say which column holds the ordered, delivered and backordered
+ * count, and (group qualifier) the words after a number that make it no exact count.
+ */
+export const quantityWordsOf = (doc: ProseDocument): QuantityWords => {
+  const entries = doc.lexicons["order-quantity-column"] ?? [];
+  return {
+    columns: entries.flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : [])),
+    qualifiers: entries.flatMap((entry) => (entry.group === "qualifier" ? [entry.pattern] : [])),
+  };
+};
+
+type RowCheck = (tables: readonly ChangeTable[], words: QuantityWords) => StructureIssue[];
+
+const detectorOf =
+  (rule: string, check: RowCheck): Detector =>
+  (doc): Finding[] => {
+    const words = quantityWordsOf(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 check(tables, words).map((issue) => ({
+      rule,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+  };
+
+export const deliveredOverOrderedDetector: Detector = detectorOf("delivered-over-ordered", deliveredOverOrdered);
+export const backorderMismatchDetector: Detector = detectorOf("backorder-mismatch", backorderMismatches);