chaffjs 0.29.0 → 0.31.0

package/src/detectors/layout-code.ts

@@ -0,0 +1,174 @@
+// layout-code-mismatch: a listing's layout code (2LDK, "3 bedrooms") against the rooms the same listing names
+// (structure/layout-codes.ts). The code letters and counted words are layout-code's, the room names layout-room's, and the
+// field names layout-label's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import {
+  foldWidth,
+  layoutSlip,
+  pairByScope,
+  parseBreakdown,
+  parseLayoutCode,
+  type Breakdown,
+  type LayoutCode,
+  type LayoutSlip,
+  type LayoutWords,
+  type LetterGroup,
+  type RoomGroup,
+} from "../structure/layout-codes.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+type LabelGroup = "code" | "breakdown" | "room-column";
+type Labels = ReadonlyMap<string, LabelGroup>;
+
+const LETTER_GROUPS: readonly LetterGroup[] = ["living", "dining", "kitchen", "storage", "one-room"];
+const ROOM_GROUPS: readonly RoomGroup[] = ["living", "dining", "kitchen", "room", "storage", "unclear"];
+const LABEL_GROUPS: readonly LabelGroup[] = ["code", "breakdown", "room-column"];
+
+const letterGroupOf = (group: string | undefined): LetterGroup | undefined => LETTER_GROUPS.find((known) => known === group);
+
+export const layoutWordsOf = (lexicons: ProseDocument["lexicons"]): LayoutWords => {
+  const code = lexicons["layout-code"] ?? [];
+  return {
+    letters: new Map(
+      code.flatMap((entry): [string, LetterGroup][] => {
+        const group = letterGroupOf(entry.group);
+        return group === undefined ? [] : [[entry.pattern, group]];
+      }),
+    ),
+    joiners: code.filter((entry) => entry.group === "joiner").map((entry) => entry.pattern),
+    counted: code.filter((entry) => entry.group === "counted").map((entry) => entry.pattern),
+    counters: code.filter((entry) => entry.group === "counter").map((entry) => entry.pattern),
+    rooms: (lexicons["layout-room"] ?? []).flatMap((entry) => {
+      const group = ROOM_GROUPS.find((known) => known === entry.group);
+      return group === undefined ? [] : [{ pattern: entry.pattern, group }];
+    }),
+  };
+};
+
+const labelKey = (label: string): string => foldWidth(withoutEdgeMarks(label)).toLowerCase().replace(/\s+/gu, " ");
+
+const labelsOf = (lexicons: ProseDocument["lexicons"]): Labels =>
+  new Map(
+    (lexicons["layout-label"] ?? []).flatMap((entry): [string, LabelGroup][] => {
+      const group = LABEL_GROUPS.find((known) => known === entry.group);
+      return group === undefined ? [] : [[labelKey(entry.pattern), group]];
+    }),
+  );
+
+/** A code found in the page, with the breakdown written right with it when there is one (a row, or 2LDK（洋室6帖・…）). */
+type PlacedCode = { readonly code: LayoutCode; readonly scope: number; readonly breakdown?: Breakdown | undefined };
+type PlacedBreakdown = { readonly breakdown: Breakdown; readonly scope: number };
+type Found = { readonly codes: PlacedCode[]; readonly breakdowns: PlacedBreakdown[] };
+const NOTHING: Found = { codes: [], breakdowns: [] };
+
+type Context = { readonly words: LayoutWords; readonly labels: Labels; readonly scopeOf: (offset: number) => number };
+
+const INLINE_BREAKDOWN = /^[^(（]*[(（]([^)）]+)[)）]/u;
+
+/** The breakdown written in brackets after the code, when it names a room. */
+const inlineBreakdown = (rest: string, words: LayoutWords): Breakdown | undefined => {
+  const inside = INLINE_BREAKDOWN.exec(rest)?.[1];
+  if (inside === undefined) return undefined;
+  const breakdown = parseBreakdown([inside], words);
+  return breakdown.rooms > 0 || breakdown.unclear ? breakdown : undefined;
+};
+
+const codeIn = (text: string, start: number, context: Context, breakdown?: Breakdown): PlacedCode[] => {
+  const found = parseLayoutCode(text, context.words);
+  if (found === undefined) return [];
+  const code = { ...found, start: start + found.start, end: start + found.end };
+  const written = breakdown ?? inlineBreakdown(text.slice(found.end), context.words);
+  return [{ code, scope: context.scopeOf(code.start), breakdown: written }];
+};
+
+const field = (group: LabelGroup | undefined, value: string, start: number, context: Context): Found => {
+  if (group === "code") return { codes: codeIn(value, start, context), breakdowns: [] };
+  if (group === "breakdown") return { codes: [], breakdowns: [{ breakdown: parseBreakdown([value], context.words), scope: context.scopeOf(start) }] };
+  return NOTHING;
+};
+
+const merged = (found: readonly Found[]): Found => ({
+  codes: found.flatMap((each) => each.codes),
+  breakdowns: found.flatMap((each) => each.breakdowns),
+});
+
+const groupOfCell = (cell: Cell | undefined, labels: Labels): LabelGroup | undefined => (cell === undefined ? undefined : labels.get(labelKey(cell.text)));
+
+/** A table with a layout column: one listing a row, with its breakdown column when the table has one. */
+const wideRows = (rows: readonly Cell[][], codeColumn: number, breakdownColumn: number, context: Context): Found => ({
+  codes: rows.flatMap((cells) => {
+    const code = cells[codeColumn];
+    const listed = cells[breakdownColumn];
+    const breakdown = listed === undefined ? undefined : parseBreakdown([listed.text], context.words);
+    return code === undefined ? [] : codeIn(code.text, code.start, context, breakdown);
+  }),
+  breakdowns: [],
+});
+
+const tableFound = (header: Line, rows: readonly Cell[][], context: Context): Found => {
+  const groups = cellsOf(header).map((cell) => groupOfCell(cell, context.labels));
+  const codeColumn = groups.indexOf("code");
+  if (codeColumn !== -1) return wideRows(rows, codeColumn, groups.indexOf("breakdown"), context);
+  if (groups[0] === "room-column") {
+    const breakdown = parseBreakdown(
+      rows.map((cells) => cells[0]?.text ?? ""),
+      context.words,
+    );
+    return { codes: [], breakdowns: [{ breakdown, scope: context.scopeOf(header.start) }] };
+  }
+  return merged(rows.map(([label, value]) => (value === undefined ? NOTHING : field(groupOfCell(label, context.labels), value.text, value.start, context))));
+};
+
+const tablesFound = (source: string, context: Context): Found =>
+  merged(tablesOf(linesOf(source)).map((table) => tableFound(table.header, table.rows.map(cellsOf), context)));
+
+const LIST_LEAD = /^\s*(?:(?:[-*+]|\d+[.)])\s+)?/u;
+const MAX_LABEL_LENGTH = 24;
+
+/** "間取り：2LDK", "- Rooms: Bedroom 1, Bedroom 2" outside tables: the name before the first colon, and the value after it. */
+const labelledLine = (line: Line, context: Context): Found => {
+  const colon = line.text.search(/[:：]/u);
+  if (colon === -1 || line.text.includes("|")) return NOTHING;
+  const label = line.text.slice(0, colon).replace(LIST_LEAD, "");
+  const rest = line.text.slice(colon + 1);
+  const value = rest.trimStart();
+  if (label.length > MAX_LABEL_LENGTH || value === "") return NOTHING;
+  return field(context.labels.get(labelKey(label)), value, line.start + colon + 1 + rest.length - value.length, context);
+};
+
+/** Code and markup are masked in prose, so a colon in code is not read. */
+const linesFound = (prose: string, context: Context): Found => merged(linesOf(prose).map((line) => labelledLine(line, context)));
+
+const scopeFinder =
+  (doc: ProseDocument) =>
+  (offset: number): number =>
+    doc.sections.findLastIndex((section) => section.span.start <= offset);
+
+const slipsOf = (found: Found): LayoutSlip[] => {
+  const direct = found.codes.flatMap((placed): [LayoutCode, Breakdown][] => (placed.breakdown === undefined ? [] : [[placed.code, placed.breakdown]]));
+  const pooled = found.codes.filter((placed) => placed.breakdown === undefined);
+  const paired = pairByScope(pooled, found.breakdowns).map(([placed, listed]): [LayoutCode, Breakdown] => [placed.code, listed.breakdown]);
+  return [...direct, ...paired].flatMap(([code, breakdown]) => layoutSlip(code, breakdown) ?? []);
+};
+
+export const layoutCode: Detector = (doc): Finding[] => {
+  const context: Context = { words: layoutWordsOf(doc.lexicons), labels: labelsOf(doc.lexicons), scopeOf: scopeFinder(doc) };
+  const found = merged([tablesFound(doc.source, context), linesFound(doc.prose ?? doc.source, context)]);
+  return slipsOf(found).map((slip) => ({
+    rule: "layout-code-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.code.start),
+    ...(slip.kind === "part" ? { variant: "part" } : {}),
+    values: {
+      code: slip.code.text,
+      stated: slip.code.rooms,
+      ...(slip.kind === "count" ? { listed: slip.listed } : { part: slip.entry }),
+      offset: slip.code.start,
+    },
+  }));
+};

package/src/detectors/measured-facts.ts

@@ -0,0 +1,20 @@
+import type { ProseDocument, StructureNode } from "../plugin.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import { factValues, type FactValue } from "../facts/fact-values.ts";
+import { codeFences } from "./code-fences.ts";
+import { measuredValues, type Measured } from "../facts/measures.ts";
+import { measureUnitsOf } from "../facts/measure-units.ts";
+
+/** 文書の中の、単位の語彙表の単位が付いた量。コードの塊の中の量は、項目の値ではない。 */
+export const measuredOf = (doc: ProseDocument): Measured[] => {
+  const fences = codeFences(doc.source);
+  return measuredValues(doc.source, measureUnitsOf(doc)).filter((value) => !fences.some((fence) => fence.start <= value.start && value.end <= fence.end));
+};
+
+/** fact-conflict の値に、単位の付いた量を足す。量と重なる値（量の数だけを読んだもの）は量に置き換える。 */
+export const valuesWith = (tree: StructureNode, doc: ProseDocument, measured: readonly Measured[]): 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/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,10 +1,17 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, type NameMention, type VariantChars } from "../name-variants.ts";
+import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, withKnownNeighbours, type NameMention, type VariantChars } from "../name-variants.ts";
+import type { SpellingInput } from "../name-spelling-chars.ts";
 import { nameCueAt, type NameCues } from "../name-cue.ts";
 import { quoteAt } from "./structure-tree.ts";
 import { companyMentionsIn, companyVariants, type CompanyForm, type IsProper } from "../company-names.ts";
-import { placeMentionsIn, placeVariants, type PlaceReader, type PlaceWord } from "../place-names.ts";
-import type { Token } from "../plugin.ts";
+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 { proseWithCells } from "../table-cells.ts";
+import { modelCodeFindings } from "./name-variant-model-codes.ts";
+import { labelledSpans, orderNamesOf, quotedSpans, stemOf, titleCaseSpans, wordOrderVariants, type OrderWord } from "../name-word-order.ts";
 
 // 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
 // （です、まで）は name-particle、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
@@ -28,10 +35,29 @@ 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"]);
 
-const tokensOf = (doc: ProseDocument): Token[] => doc.sentences.flatMap((sentence) => sentence.tokens ?? []);
+/** 表の本体の升。本文が表を覆わない文書（Markdown でない）には無い。 */
+const cellsOf = (doc: ProseDocument): readonly TableCell[] => doc.tableCells?.() ?? tableBodyCells(proseAndTablesOf(doc));
+
+/** 文の語と表の升の語を、文書の順に。 */
+const tokensOf = (doc: ProseDocument): Token[] =>
+  [...doc.sentences.flatMap((sentence) => sentence.tokens ?? []), ...cellsOf(doc).flatMap((cell) => cell.tokens ?? [])].toSorted(
+    (left, right) => left.span.start - right.span.start,
+  );
 
 /** 場所の名前の語の数の上限。名前の読みを探す範囲。 */
 const MAX_PLACE_TOKENS = 20;
@@ -74,37 +100,95 @@ const companyFindings = (doc: ProseDocument, prose: string, reported: readonly R
     .filter(({ mention }) => !overlapsAny(reported, mention.offset, mention.surface.length))
     .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind: kind === "spelling" ? kind : `company-${kind}` }));
 
-/** 場所の名前の書き分け。人や会社の名前の見方がすでに指した所と重なるものは除く。 */
-const placeFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] =>
-  placeVariants(placeMentionsIn(prose, placeWordsOf(doc), placeReaderOf(doc)))
+/** 場所の名前の書き分け。表の本体の升の中の名前も読む（見出しの行は読まない）。人や会社の名前の見方がすでに指した所と重なるものは除く。 */
+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 }));
 
+/** 名前の中で比べる語の品詞。助詞や冠詞（の、of）は語の順に数えない。 */
+const CONTENT_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN", "ADJ", "NUM", "VERB"]);
+
+/** 欄の後ろの名前を切る所: 内容語でも名前の中の小さな語（of）でもない語の頭。 */
+const orderStopsOf = (doc: ProseDocument): number[] => {
+  const joiners = new Set(patternsOf(doc, "name-title-joiner"));
+  return tokensOf(doc)
+    .filter((token) => !CONTENT_POS.has(token.pos) && !joiners.has(token.surface.toLowerCase()))
+    .map((token) => token.span.start);
+};
+
+const sentenceStartsOf = (doc: ProseDocument): ReadonlySet<number> => new Set(doc.sentences.flatMap((sentence) => sentence.tokens?.[0]?.span.start ?? []));
+
+const orderWordsOf = (doc: ProseDocument): OrderWord[] => {
+  const suffixes = patternsOf(doc, "name-stem-suffix");
+  return tokensOf(doc)
+    .filter((token) => CONTENT_POS.has(token.pos))
+    .map((token) => ({ start: token.span.start, end: token.span.end, key: stemOf(token.surface, suffixes) }));
+};
+
+/**
+ * 語の順を入れ替えて書いた同じ名前（統計学基礎 と 基礎統計学）。名前と読める所は、括弧の中（name-quote）、大文字で始まる語の並び
+ * （name-title-joiner を挟んでよい）、名前を書く欄の後ろ（name-label）。大文字の語の並びどうしは、片方が表の升まるごとに
+ * 書いた名前のときだけ比べる。ほかの見方がすでに指した所と重なるものは除く。
+ */
+const orderFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] => {
+  const starts = sentenceStartsOf(doc);
+  const spans = [
+    ...quotedSpans(prose, patternsOf(doc, "name-quote")),
+    ...titleCaseSpans(prose, patternsOf(doc, "name-title-joiner"), (offset) => starts.has(offset)),
+    ...labelledSpans(prose, patternsOf(doc, "name-label")),
+  ];
+  const cells = new Set(tableBodyCells(proseAndTablesOf(doc)).map((cell) => cell.text.trim()));
+  return wordOrderVariants(orderNamesOf(doc.source, spans, orderWordsOf(doc), orderStopsOf(doc)), cells)
+    .filter(({ name }) => !overlapsAny(reported, name.offset, name.surface.length))
+    .map(({ name, usual }) => ({ offset: name.offset, name: name.surface, usual, kind: "order" }));
+};
+
 /** 人・製品・会社の名前の現れ。解析器が固有名詞と読む語、敬称の付く名前、前後の語で名前と読める漢字。 */
 const nameMentionsOf = (doc: ProseDocument, prose: string, chars: VariantChars): NameMention[] => {
   const cues: NameCues = { leads: patternsOf(doc, "person-lead"), suffixes: patternsOf(doc, "person-suffix"), particles: patternsOf(doc, "name-particle") };
   const tagged = doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source, cues.suffixes));
   const taggedOrSuffixed = [...tagged, ...suffixedNamesIn(prose, cues.suffixes, chars, tagged)];
-  return [...taggedOrSuffixed, ...cuedNamesIn(prose, cues, chars, taggedOrSuffixed)]
-    .map((mention): NameMention => {
-      const cue = mention.cue ?? nameCueAt(prose, mention.offset, mention.surface, cues);
-      return cue === undefined ? mention : { ...mention, cue };
-    })
-    .toSorted((left, right) => left.offset - right.offset);
+  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);
 };
 
+/** 一語の名前の中で同じ音を書く字（ヶ・ケ・が）は語彙表 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))
+    .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 }));
+
 /** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
 export const nameVariant: Detector = (doc): Finding[] => {
   const prose = doc.prose ?? doc.source;
   const chars = variantCharsOf(doc);
-  const names = nameVariants(nameMentionsOf(doc, prose, chars), chars).map(({ mention, usual, kind }): Reported => ({
+  const mentions = nameMentionsOf(doc, prose, chars);
+  const names = nameVariants(mentions, chars, spellingInputOf(doc)).map(({ mention, usual, kind }): Reported => ({
     offset: mention.offset,
     name: mention.surface,
     usual,
     kind,
   }));
   const namesAndCompanies = [...names, ...companyFindings(doc, prose, names)];
-  return [...namesAndCompanies, ...placeFindings(doc, prose, namesAndCompanies)]
+  const withTables = [...namesAndCompanies, ...tableFindings(doc, prose, mentions, namesAndCompanies)];
+  const withPlaces = [...withTables, ...placeFindings(doc, prose, withTables, chars)];
+  const withOrder = [...withPlaces, ...orderFindings(doc, prose, withPlaces)];
+  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/orthographic-variant.ts

@@ -1,6 +1,6 @@
-import type { Detector, Finding, ProseDocument, Sentence, Token } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, TableCell, Token } from "../plugin.ts";
 import { groupBy, oddSpellings, type KeyedWord, type OddSpelling } from "../spelling-variants.ts";
-import { dropsOkurigana, kanjiSkeleton, katakanaKey, lemmaReading } from "../kana-spelling.ts";
+import { dropsOkurigana, kanjiKeyAmong, katakanaKey, lemmaReading } from "../kana-spelling.ts";
 import { isKatakanaWord, stemOf } from "../long-vowel.ts";
 import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
@@ -12,7 +12,14 @@ import { isPartOfAddress } from "./address-word.ts";
  * A word found in the document: where it is, which sentence it is in, its key and spelling, how it is written when that differs, and
  * whether it is written onto the noun after it (取扱事業者).
  */
-type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string; readonly compoundHead?: boolean };
+type Placed = KeyedWord & {
+  readonly sentence: Sentence;
+  readonly offset: number;
+  readonly shown?: string;
+  readonly compoundHead?: boolean;
+  /** Where a run of words ends (タイヤレバー). */
+  readonly end?: number;
+};
 
 type IsOpen = (start: number, end: number) => boolean;
 
@@ -141,11 +148,12 @@ const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[
  */
 const byKanji = (words: readonly Placed[]): Placed[] =>
   [...groupBy(words, (word) => word.key).values()].flatMap((group) => {
-    const skeletons = [...new Set(group.map((word) => kanjiSkeleton(word.spelling)).filter((skeleton) => skeleton !== ""))];
     const spellings = [...new Set(group.map((word) => word.spelling))];
+    const skeletonOf = (spelling: string): string => kanjiKeyAmong(spelling, spellings);
+    const skeletons = [...new Set(spellings.map(skeletonOf).filter((skeleton) => skeleton !== ""))];
     const apart = spellings.some((spelling) => dropsOkurigana(spelling, spellings)) ? "|compound" : "";
     return group.flatMap((word): Placed[] => {
-      const own = kanjiSkeleton(word.spelling);
+      const own = skeletonOf(word.spelling);
       if (own === "" && skeletons.length > 1) return [];
       const use = word.compoundHead === true ? apart : "";
       return [{ ...word, key: `${word.key}|${own === "" ? (skeletons[0] ?? "") : own}${use}` }];
@@ -161,6 +169,44 @@ const katakanaWords = (sentence: Sentence, isOpen: IsOpen): Placed[] =>
     return [...key].length < MIN_KATAKANA_KEY ? [] : [{ key: `kana|${key}`, spelling: stemOf(token.surface), sentence, offset: token.span.start }];
   });
 
+const isKatakanaNoun = (token: Token): boolean => token.pos === "NOUN" && isKatakanaWord(token.surface);
+
+/** Katakana nouns written onto each other (タイヤ and レバー in タイヤレバー), each run whole: one place may be cut into words another is not. */
+const katakanaRuns = (tokens: readonly Token[]): Token[][] =>
+  tokens.reduce<Token[][]>((runs, token, at) => {
+    if (!isKatakanaNoun(token)) return runs;
+    const last = runs.at(-1);
+    if (last !== undefined && isTouching(tokens[at - 1], token) && last.at(-1) === tokens[at - 1]) last.push(token);
+    else runs.push([token]);
+    return runs;
+  }, []);
+
+/**
+ * Katakana runs keyed like one katakana word, spelled as their words' stems joined: タイヤーレバー (one unknown word) meets
+ * タイヤレバー read as タイヤ and レバー, while the final ー of a word inside the run (サーバーリスト and サーバリスト) stays katakana-long-vowel's.
+ */
+const katakanaRunWords = (sentence: Sentence, isOpen: IsOpen): Placed[] =>
+  katakanaRuns(sentence.tokens ?? []).flatMap((run): Placed[] => {
+    const [first, last] = [run[0], run.at(-1)];
+    if (first === undefined || last === undefined) return [];
+    const [start, end] = [first.span.start - sentence.span.start, last.span.end - sentence.span.start];
+    const key = katakanaKey(run.map((token) => token.surface).join(""));
+    if ([...key].length < MIN_KATAKANA_KEY || !isOpen(start, end)) return [];
+    return [
+      {
+        key: `kana|${key}`,
+        spelling: run.map((token) => stemOf(token.surface)).join(""),
+        shown: run.map((token) => token.surface).join(""),
+        sentence,
+        offset: first.span.start,
+        end: last.span.end,
+      },
+    ];
+  });
+
+/** Whether a run holds a place another key already points at: the word inside it is said, not the run around it. */
+const coversOffset = (run: Placed, offset: number): boolean => offset >= run.offset && offset < (run.end ?? run.offset + 1);
+
 const LATIN_WORD = /[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*/gu;
 const LOWER = /\p{Ll}/u;
 
@@ -204,6 +250,23 @@ const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding
   values: { written: odd.word.shown ?? odd.word.spelling, other: shownUsual(words, odd), count: odd.count, of: odd.of, offset: odd.word.offset },
 });
 
+/** A cell that is one Latin word in lower case (openapi, contentType): a field name or a value, spelled by the data and not by the writer. */
+const DATA_KEY_CELL = /^\p{Ll}[A-Za-z0-9]*$/u;
+
+type Place = { readonly sentence: Sentence; readonly isOpen: IsOpen; readonly readsLatin: boolean };
+
+/** A link's brackets and where it goes (`[`, `](#contentType)`, `][ref]`). The prose hides them outside tables; a cell keeps the Markdown as written. */
+const LINK_CHROME = /\]\([^)]*\)|\]\[[^\]]*\]|\[/gu;
+
+const withoutLinkChrome = (text: string): string => text.replaceAll(LINK_CHROME, (chrome) => " ".repeat(chrome.length));
+
+/** A body cell of a table read as a sentence of its own: the prose covers tables, so a cell's words (片栗粉 in a list of ingredients) are not in the sentences. Header rows stay out. */
+const cellPlace = (cell: TableCell, names: readonly string[]): Place => {
+  const text = withoutLinkChrome(cell.text);
+  const sentence: Sentence = { span: { start: cell.start, end: cell.end }, text, tokens: cell.tokens ?? [] };
+  return { sentence, isOpen: isOpenIn(sentence, names), readsLatin: !DATA_KEY_CELL.test(text.trim()) };
+};
+
 /**
  * One word written two ways in one document (出来る and できる, 引っ越し and 引越し, ウィンドウ and ウインドウ, e-mail and email),
  * found without a list of words: the document's own words are grouped by reading or by an evened-out spelling, and the way the
@@ -211,12 +274,18 @@ const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding
  */
 export const orthographicVariant: Detector = (doc, options): Finding[] => {
   const skips: Skips = { skip: new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]), idioms: new Set(patternsOf(doc, IDIOM)) };
-  const placed = doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, doc.names ?? []) }));
+  const names = doc.names ?? [];
+  const placed: Place[] = [
+    ...doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, names), readsLatin: true })),
+    ...(doc.tableCells?.() ?? []).map((cell) => cellPlace(cell, names)),
+  ];
   const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skips)));
   const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
-  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skips.skip));
+  const runs = placed.flatMap(({ sentence, isOpen }) => katakanaRunWords(sentence, isOpen));
+  const latin = placed.flatMap(({ sentence, isOpen, readsLatin }) => (readsLatin ? latinWords(sentence, isOpen, skips.skip) : []));
   const odd = [reading, katakana, latin].flatMap((words) => oddSpellings(words, options.limit));
-  const all = [...reading, ...katakana, ...latin];
+  const oddRuns = oddSpellings(runs, options.limit).filter(({ word }) => !odd.some((other) => coversOffset(word, other.word.offset)));
+  const all = [...reading, ...katakana, ...runs, ...latin];
   // A word can be odd by its reading and by its katakana key at once; one place is said once.
-  return [...new Map(odd.map((entry) => [entry.word.offset, entry])).values()].map((entry) => findingOf(all, entry));
+  return [...new Map([...odd, ...oddRuns].map((entry) => [entry.word.offset, entry])).values()].map((entry) => findingOf(all, entry));
 };

package/src/detectors/orthography.ts

@@ -5,6 +5,7 @@ import { minorityReport } from "../spacing-minority.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStarts, type NameContext } from "../number-name.ts";
 import { isSpacedLocationPart, type FloorWords } from "../location-part.ts";
+import { addressSpans, clockTimeSpans, isInsideSpan } from "../spacing-code.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -70,18 +71,27 @@ const followsItemNumber = (text: string, boundary: Boundary, itemNumbers: Readon
 const calendarStarts = (sentence: Sentence, units: CalendarUnits): ReadonlySet<number> =>
   new Set(calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run }) => run.start));
 
+/** 英字の側がメールアドレスか URL の境目。後ろの空白は、アドレスの終わりを示す区切り。 */
+const besideAddress = (addresses: readonly Span[], boundary: Boundary): boolean =>
+  isInsideSpan(addresses, boundary.offset - 1) || isInsideSpan(addresses, boundary.spaced ? boundary.offset + 1 : boundary.offset);
+
+/** 文の中で一度だけ探すもの: 日付・時刻の数の頭の位置、コロンで書いた時刻、メールアドレス・URL。 */
+type SentenceCodes = { readonly calendar: ReadonlySet<number>; readonly clockTimes: readonly Span[]; readonly addresses: readonly Span[] };
+
 /**
  * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目、文頭の項目の番号（「一 JIS」）の後ろの境目は、空け方の好みではないので数えない。
- * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。
+ * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。コロンで書いた時刻（13:30）も同じ。
+ * メールアドレス・URL の前後の境目も数えない（spacing-code.ts）。
  * 「本社 5階」のように名前の後ろに空白で区切った階・部屋の番号の前の空白も、所在の組の区切りなので数えない（location-part.ts）。
  */
-const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlySet<number>): boolean => {
+const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, codes: SentenceCodes): boolean => {
   if (followsItemNumber(sentence.text, boundary, context.itemNumbers)) return false;
   if (boundary.kind !== "after-digit" && endsWithDivisionLabel(sentence.text.slice(0, boundary.offset), context.divisions)) return false;
-  if (boundary.kind === "letter") return true;
+  if (boundary.kind === "letter") return !besideAddress(codes.addresses, boundary);
+  if (isInsideSpan(codes.clockTimes, digitBeside(boundary))) return false;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
   if (run === undefined) return true;
-  if (calendar.has(run.start)) return false;
+  if (codes.calendar.has(run.start)) return false;
   if (boundary.kind === "before-digit" && isSpacedLocationPart(sentence.text, run, sentence.tokens, sentence.span.start, context.floors)) return false;
   return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context);
 };
@@ -153,10 +163,10 @@ export const latinSpacing: Detector = (doc, options): Finding[] => {
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);
-    const calendar = calendarStarts(sentence, context.calendar);
+    const codes = { calendar: calendarStarts(sentence, context.calendar), clockTimes: clockTimeSpans(sentence.text), addresses: addressSpans(sentence.text) };
     return latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
       .filter((boundary) => !isQuoted(quoted, boundary) && !isInsideLink(doc.links, sentence.span.start + boundary.offset))
-      .filter((boundary) => isCounted(sentence, boundary, context, calendar))
+      .filter((boundary) => isCounted(sentence, boundary, context, codes))
       .map((boundary) => ({ sentence, ...boundary }));
   });
   return KINDS.flatMap((kind) =>

package/src/detectors/party-order.ts

@@ -0,0 +1,50 @@
+// Party names listed in the reverse of the document's usual order (乙及び甲 where the contract otherwise writes 甲及び乙). The
+// names are the parties the document defines and the language package's standard ones (party-order-label); the words that list
+// them are its party-order-joiner list. A direction (乙から甲へ, 甲が乙に) is no listing and is not read.
+import { definedTerms } from "../structure/definition-use.ts";
+import { partiesOf } from "../structure/party-role.ts";
+import { partyListings, reversedListings, type ListingWords } from "../structure/party-order.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+/** The usual order is the one written at least this many times as often as its reverse: a tie or near-tie is no convention. */
+const MIN_USUAL_RATIO = 2;
+const SERIES_GROUP = "series";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const listingWords = (doc: ProseDocument): ListingWords => {
+  const standard = patternsOf(doc, "party-order-label");
+  const terms = doc.structure === undefined ? [] : definedTerms(doc.structure);
+  const parties = partiesOf(doc.source, terms, {
+    roles: patternsOf(doc, "party-role"),
+    shortNames: patternsOf(doc, "party-short-name"),
+    companyForms: patternsOf(doc, "company-form"),
+  });
+  const joiners = doc.lexicons["party-order-joiner"] ?? [];
+  return {
+    labels: [...new Set([...standard, ...parties.map((party) => party.term)])],
+    bareLabels: standard,
+    joiners: joiners.filter((entry) => entry.group !== SERIES_GROUP).map((entry) => entry.pattern),
+    seriesMarks: joiners.filter((entry) => entry.group === SERIES_GROUP).map((entry) => entry.pattern),
+  };
+};
+
+export const partyOrder: Detector = (doc): Finding[] => {
+  const texts = doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
+  const textOf = (listing: { readonly start: number; readonly end: number }): string => doc.source.slice(listing.start, listing.end);
+  return reversedListings(partyListings(texts, listingWords(doc)), MIN_USUAL_RATIO).map((slip) => ({
+    rule: "party-order",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.listing.start),
+    values: {
+      written: textOf(slip.listing),
+      usual: textOf(slip.usual),
+      usualCount: slip.usualCount,
+      reverseCount: slip.reverseCount,
+      offset: slip.listing.start,
+    },
+  }));
+};