chaffjs 0.28.0 → 0.30.0

package/src/detectors/open-end-names.ts

@@ -0,0 +1,140 @@
+import type { LexiconEntry, ProseDocument, Sentence, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { entryRanges, type TokenRange } from "./lexicon-match.ts";
+
+// A word that leaves a list open (等, etc.) is also part of names a document gives itself: 「業務執行取締役等」,
+// 銀行等（…をいう。）, the head of a definition item (四の二 親会社等 …をいう。), and longer nouns built on them
+// (監査等委員会設置会社). There the document closes the list, so the word leaves nothing open. Pure: the document and the
+// language's words come in.
+
+/** The parts of speech a name is made of. */
+const NAME_POS = new Set(["NOUN", "PROPN"]);
+/** A quoted name: what 「」『』“”"" hold, short enough to be a term rather than a sentence. */
+const QUOTED = /[「『“"]([^「」『』“”"\n]{1,40})[」』”"]/gu;
+/** The brackets of an aside that can define the name in front of it: 銀行等（銀行…をいう。）. */
+const ASIDE_CLOSE: Readonly<Record<string, string>> = { "（": "）", "(": ")" };
+/** How far an aside is read for its closing bracket. A definition's aside is a clause, not a page. */
+const MAX_ASIDE_CHARS = 600;
+/** The label before the head of a definition item, with the space after it (四の二 , (a) ). */
+const ITEM_LABEL = /^\s*\S{1,8}\s+$/u;
+/** A word right after the head that makes it the subject of a sentence (親会社等は), not the head of an item. */
+const FUNCTION_POS = new Set(["ADP", "AUX", "PART", "SCONJ", "CCONJ", "PUNCT"]);
+
+/**
+ * One place where an open-end word stands: its sentence's tokens, the tokens the word covers, the noun it is part of
+ * (first and last token: 監査 … 会社 around 等 in 監査等委員会設置会社), and the word's document offsets.
+ */
+type Occurrence = {
+  readonly sentence: Sentence;
+  readonly tokens: readonly Token[];
+  readonly range: TokenRange;
+  readonly first: number;
+  readonly last: number;
+  readonly start: number;
+  readonly end: number;
+};
+
+/** A quoted name and where the open-end word stands in it. */
+type QuotedName = { readonly name: string; readonly at: readonly number[] };
+
+/**
+ * The names a document gives that contain an open-end word: the ones it quotes, the ones it defines in an aside right
+ * after them (whole, as written there), and the heads of its definition items (which may run on into the definition).
+ */
+export type OpenEndNames = { readonly quoted: readonly QuotedName[]; readonly defined: ReadonlySet<string>; readonly heads: readonly string[] };
+
+const attached = (left: Token | undefined, right: Token | undefined): boolean =>
+  left !== undefined && right !== undefined && left.span.end === right.span.start;
+const isNameToken = (token: Token | undefined): boolean => token !== undefined && NAME_POS.has(token.pos);
+
+/** The index of the first noun of the run written right before index, or index itself when none is. */
+const runStart = (tokens: readonly Token[], index: number): number =>
+  isNameToken(tokens[index - 1]) && attached(tokens[index - 1], tokens[index]) ? runStart(tokens, index - 1) : index;
+
+/** The index of the last noun of the run written right after index, or index itself when none is. */
+const runEnd = (tokens: readonly Token[], index: number): number =>
+  isNameToken(tokens[index + 1]) && attached(tokens[index], tokens[index + 1]) ? runEnd(tokens, index + 1) : index;
+
+const occurrencesIn = (sentence: Sentence, entry: LexiconEntry): Occurrence[] => {
+  const tokens = sentence.tokens ?? [];
+  return entryRanges(sentence, entry).flatMap((range) => {
+    const firstWord = tokens[range.start];
+    const lastWord = tokens[range.end - 1];
+    if (firstWord === undefined || lastWord === undefined) return [];
+    const first = runStart(tokens, range.start);
+    const last = runEnd(tokens, range.end - 1);
+    return [{ sentence, tokens, range, first, last, start: firstWord.span.start, end: lastWord.span.end }];
+  });
+};
+
+const startOf = (occurrence: Occurrence, index: number): number => occurrence.tokens[index]?.span.start ?? occurrence.start;
+const endOf = (occurrence: Occurrence, index: number): number => occurrence.tokens[index]?.span.end ?? occurrence.end;
+
+/** The noun the word is part of, as written (当該監査等委員会). */
+const nounOf = (source: string, occurrence: Occurrence): string => source.slice(startOf(occurrence, occurrence.first), endOf(occurrence, occurrence.last));
+
+/** The text inside the aside that opens at offset, or undefined when none opens there or it does not close soon. */
+export const asideAt = (source: string, offset: number): string | undefined => {
+  const open = source.charAt(offset);
+  const close = ASIDE_CLOSE[open];
+  if (close === undefined) return undefined;
+  const chars = Array.from(source.slice(offset + 1, offset + 1 + MAX_ASIDE_CHARS));
+  const depths: number[] = [];
+  chars.forEach((char) => depths.push((depths.at(-1) ?? 1) + (char === open ? 1 : 0) - (char === close ? 1 : 0)));
+  const end = depths.indexOf(0);
+  return end === -1 ? undefined : chars.slice(0, end).join("");
+};
+
+const says = (text: string, statements: readonly string[]): boolean => statements.some((word) => text.includes(word));
+
+/** Whether the noun is defined in the aside right after it (銀行等（銀行…をいう。）). */
+const definedInAside = (source: string, occurrence: Occurrence, statements: readonly string[]): boolean => {
+  const aside = asideAt(source, endOf(occurrence, occurrence.last));
+  return aside !== undefined && says(aside, statements);
+};
+
+/** Whether the noun heads a definition item: a label before it, no particle right after the word, and a definition in the rest (四の二 親会社等 …をいう。). */
+const headsItem = (source: string, occurrence: Occurrence, statements: readonly string[]): boolean => {
+  const next = occurrence.tokens[occurrence.range.end];
+  if (next !== undefined && next.surface.trim() !== "" && FUNCTION_POS.has(next.pos)) return false;
+  const before = source.slice(occurrence.sentence.span.start, startOf(occurrence, occurrence.first));
+  return ITEM_LABEL.test(before) && says(source.slice(endOf(occurrence, occurrence.last), occurrence.sentence.span.end), statements);
+};
+
+const quotedNames = (source: string, words: readonly LexiconEntry[]): QuotedName[] =>
+  [...source.matchAll(QUOTED)].flatMap((match) => {
+    const name = match[1] ?? "";
+    const at = words.flatMap((word) => [...name.matchAll(new RegExp(escapeRegExp(word.pattern), "gu"))].map((found) => found.index));
+    return at.length === 0 ? [] : [{ name, at }];
+  });
+
+/** The names a document gives that contain an open-end word. statements: the language's words of a definition (をいう, means). */
+export const openEndNames = (doc: ProseDocument, words: readonly LexiconEntry[], statements: readonly string[]): OpenEndNames => {
+  const occurrences = doc.sentences.flatMap((sentence) => words.flatMap((word) => occurrencesIn(sentence, word)));
+  const defined = occurrences.filter((occurrence) => definedInAside(doc.source, occurrence, statements)).map((occurrence) => nounOf(doc.source, occurrence));
+  const heads = occurrences.filter((occurrence) => headsItem(doc.source, occurrence, statements)).map((occurrence) => nounOf(doc.source, occurrence));
+  return { quoted: quotedNames(doc.source, words), defined: new Set(defined), heads: [...new Set(heads)] };
+};
+
+/** Whether a quoted name holds this occurrence: the text around it reads the whole name (当該責任追及等 holds 「責任追及等」). */
+const inQuotedName = (source: string, occurrence: Occurrence, quoted: readonly QuotedName[]): boolean =>
+  quoted.some(({ name, at }) => at.some((index) => source.startsWith(name, occurrence.start - index)));
+
+/**
+ * The parts of the noun, cut at word boundaries, that hold the word and a noun before it: 当該監査等委員, 監査等委員, 監査等 … for 当該監査等委員.
+ * A part that is a defined name narrows it (当該金銭等, 特定役員等), and the definition closes its list.
+ */
+const partsHoldingWord = (source: string, occurrence: Occurrence): string[] => {
+  const { tokens, range, first, last } = occurrence;
+  const starts = tokens.slice(first, range.start).map((token) => token.span.start);
+  const ends = tokens.slice(range.end - 1, last + 1).map((token) => token.span.end);
+  return starts.flatMap((start) => ends.map((end) => source.slice(start, end)));
+};
+
+const isNamed = (source: string, occurrence: Occurrence, names: OpenEndNames): boolean =>
+  inQuotedName(source, occurrence, names.quoted) ||
+  partsHoldingWord(source, occurrence).some((part) => names.defined.has(part) || names.heads.some((head) => head.startsWith(part)));
+
+/** Where the word first stands outside a name the document gives (its document offset), or undefined when it never does. */
+export const openEndAt = (doc: ProseDocument, sentence: Sentence, word: LexiconEntry, names: OpenEndNames): number | undefined =>
+  occurrencesIn(sentence, word).find((occurrence) => !isNamed(doc.source, occurrence, names))?.start;

package/src/detectors/ordinal-run-gaps.ts

@@ -0,0 +1,101 @@
+// The leads numbering-gap reads for a schedule's numbered runs (第N回, Week N): the first cell of each table's rows, the
+// start of each list's items, and the start of each section's other lines. The comparison is structure/ordinal-runs.ts.
+import type { ProseDocument, Section } from "../plugin.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { runsOf } from "../structure/runs.ts";
+import type { StructureIssue } from "../structure/issues.ts";
+import { framesAt, ordinalFramesOf, ordinalRunBreaks, ordinalRuns, type Lead, type OrdinalFrame } from "../structure/ordinal-runs.ts";
+
+type Line = { readonly start: number; readonly text: string };
+
+/** A table, a list or a section's lines: the leads compared as one block, and where the block's first lead is. */
+type Block = { readonly leads: readonly Lead[]; readonly start: number };
+
+const EMPHASIS = String.raw`(?:\*\*|__|\*|_)?`;
+const TABLE_LEAD = new RegExp(String.raw`^[ \t]*\|?[ \t]*${EMPHASIS}`, "u");
+const LIST_LEAD = new RegExp(String.raw`^[ \t]*(?:[-*+]|\d{1,9}[.)])[ \t]+(?:\[[ xX]\][ \t]+)?${EMPHASIS}`, "u");
+const LINE_LEAD = new RegExp(String.raw`^[ \t\u3000]*${EMPHASIS}`, "u");
+const QUOTED_LINE = /^[ \t]*>/u;
+
+const linesOf = (text: string): Line[] => {
+  const starts = [0, ...[...text.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ start, text: text.slice(start, (starts[index + 1] ?? text.length + 1) - 1) }));
+};
+
+const lineAt = (text: string, offset: number): string => {
+  const end = text.indexOf("\n", offset);
+  return text.slice(offset, end === -1 ? text.length : end);
+};
+
+const leadOf = (text: string, offset: number, marks: RegExp, frames: readonly OrdinalFrame[]): Lead => {
+  const line = lineAt(text, offset);
+  const skipped = marks.exec(line)?.[0].length ?? 0;
+  return { offset: offset + skipped, read: framesAt(line.slice(skipped), frames) };
+};
+
+const tableBlocks = (text: string, frames: readonly OrdinalFrame[]): Block[] =>
+  runsOf(text)
+    .filter((run) => run[0]?.kind === "table" && run.length > 0)
+    .map((run) => ({ leads: run.map((line) => leadOf(text, line.start, TABLE_LEAD, frames)), start: run[0]?.start ?? 0 }));
+
+const isQuotedAt = (source: string, offset: number): boolean => QUOTED_LINE.test(lineAt(source, source.lastIndexOf("\n", offset - 1) + 1));
+
+const listBlocks = (doc: ProseDocument, text: string, frames: readonly OrdinalFrame[]): Block[] =>
+  doc.lists
+    .filter((list) => !isQuotedAt(doc.source, list.span.start))
+    .map((list) => ({ leads: list.itemSpans.map((item) => leadOf(text, item.start, LIST_LEAD, frames)), start: list.span.start }));
+
+const sectionIndexAt = (sections: readonly Section[], offset: number): number => sections.findLastIndex((section) => section.span.start <= offset);
+
+/** The lines outside tables, lists and quotations, one block per section. */
+const lineBlocks = (doc: ProseDocument, text: string, frames: readonly OrdinalFrame[]): Block[] => {
+  const inList = (offset: number): boolean => doc.lists.some((list) => offset >= list.span.start && offset < list.span.end);
+  const bySection = new Map<number, Lead[]>();
+  linesOf(text)
+    .filter((line) => !line.text.includes("|"))
+    .map((line) => leadOf(text, line.start, LINE_LEAD, frames))
+    .filter((lead) => lead.read.length > 0 && !inList(lead.offset) && !isQuotedAt(doc.source, lead.offset))
+    .forEach((lead) => {
+      const key = sectionIndexAt(doc.sections, lead.offset);
+      const leads = bySection.get(key) ?? [];
+      leads.push(lead);
+      bySection.set(key, leads);
+    });
+  return [...bySection.values()].map((leads) => ({ leads, start: leads[0]?.offset ?? 0 }));
+};
+
+/** How many lines above a block are read for a word saying it lists only some items (a caption, a table's header row). */
+const LINES_ABOVE = 3;
+const LATIN_WORD = /^[A-Za-z][A-Za-z ]*$/u;
+
+const markerTest = (marker: string): ((text: string) => boolean) => {
+  if (!LATIN_WORD.test(marker)) return (text) => text.includes(marker);
+  const word = new RegExp(String.raw`(?<![A-Za-z])${marker}(?![A-Za-z])`, "iu");
+  return (text) => word.test(text);
+};
+
+/** The heading over the block and the few lines right above it, as written. */
+const contextAbove = (doc: ProseDocument, start: number): string => {
+  const section = doc.sections[sectionIndexAt(doc.sections, start)];
+  const from = section?.span.start ?? 0;
+  const above = linesOf(doc.source.slice(from, start))
+    .map((line) => line.text)
+    .filter((line) => line.trim() !== "")
+    .slice(-LINES_ABOVE);
+  return [section?.heading ?? "", ...above].join("\n");
+};
+
+/**
+ * The skips and repeats in the document's 第N回 / Week N runs. A block whose heading or the lines right above it say it
+ * lists only some (抜粋, selected) is not read: its numbers skip by choice.
+ */
+export const ordinalRunGaps = (doc: ProseDocument): StructureIssue[] => {
+  const frames = ordinalFramesOf(doc.lexicons["ordinal-frame"] ?? []);
+  if (frames.length === 0) return [];
+  const partial = (doc.lexicons["partial-listing-marker"] ?? []).map((entry) => markerTest(entry.pattern));
+  const text = proseAndTablesOf(doc);
+  return [...tableBlocks(text, frames), ...listBlocks(doc, text, frames), ...lineBlocks(doc, text, frames)]
+    .filter((block) => block.leads.some((lead) => lead.read.length > 0))
+    .filter((block) => !partial.some((names) => names(contextAbove(doc, block.start))))
+    .flatMap((block) => ordinalRuns(block.leads).flatMap(ordinalRunBreaks));
+};

package/src/detectors/orthographic-variant.ts

@@ -1,14 +1,18 @@
 import type { Detector, Finding, ProseDocument, Sentence, Token } from "../plugin.ts";
 import { groupBy, oddSpellings, type KeyedWord, type OddSpelling } from "../spelling-variants.ts";
-import { kanjiSkeleton, katakanaKey, lemmaReading } from "../kana-spelling.ts";
+import { dropsOkurigana, kanjiSkeleton, 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";
 import { furiganaSpans } from "../furigana.ts";
 import { acronymsIn, isCapitalsNotSpelling } from "../capitals-with-small.ts";
+import { isPartOfAddress } from "./address-word.ts";
 
-/** A word found in the document: where it is, which sentence it is in, its key and spelling, and how it is written when that differs. */
-type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string };
+/**
+ * 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 IsOpen = (start: number, end: number) => boolean;
 
@@ -50,7 +54,21 @@ const followsTeForm = (previous: Token | undefined): boolean =>
   (previous?.pos === "SCONJ" && (previous.surface === "て" || previous.surface === "で")) ||
   (previous?.pos === "CCONJ" && TE_FORM_CONJUNCTION.test(previous.surface));
 
-const isHelper = ({ token, previous }: InContext): boolean => token.features?.["Bound"] === "Yes" || followsTeForm(previous);
+/** は or も after a word ending in で, て or く: the ない after them negates (事実ではない, どれでもない, 高くはない); it is not 無い. */
+const TOPIC_AFTER_LINK = new Set(["は", "も"]);
+const LINK_END = /[でてく]$/u;
+const NEGATION = new Set(["ない", "無い"]);
+
+/** では and でも read as one word after a space (2 ではなく). */
+const LINK_AND_TOPIC = new Set(["では", "でも"]);
+
+const followsLinkAndTopic = (previous: Token | undefined, before: Token | undefined): boolean =>
+  LINK_AND_TOPIC.has(previous?.surface ?? "") || (previous?.pos === "ADP" && TOPIC_AFTER_LINK.has(previous.surface) && LINK_END.test(before?.surface ?? ""));
+
+const negatesAfterTopic = ({ token, previous, before }: InContext): boolean =>
+  token.pos === "ADJ" && NEGATION.has(token.lemma ?? "") && followsLinkAndTopic(previous, before);
+
+const isHelper = (word: InContext): boolean => word.token.features?.["Bound"] === "Yes" || followsTeForm(word.previous) || negatesAfterTopic(word);
 
 const isTouching = (left: Token | undefined, right: Token): boolean => left !== undefined && left.span.end === right.span.start;
 
@@ -84,6 +102,13 @@ const KATAKANA_END = /\p{Script=Katakana}$/u;
 const isCutFromKatakana = ({ token, previous }: InContext): boolean =>
   ONE_KATAKANA_HEAD.test(token.surface) && token.surface.length > 1 && isTouching(previous, token) && KATAKANA_END.test(previous?.surface ?? "");
 
+/**
+ * で read as the verb 出る right after a word with no particle between (JSON でない): the copula's で, which the tokenizer
+ * misreads after a space or a name. 出る after a particle (結果がでない) or at the head of a sentence (でない音) is the verb.
+ */
+const isCopulaReadAsVerb = ({ token, previous }: InContext): boolean =>
+  token.pos === "VERB" && token.surface === "で" && previous !== undefined && previous.pos !== "ADP";
+
 type Skips = { readonly skip: ReadonlySet<string>; readonly idioms: ReadonlySet<string> };
 
 const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefined => {
@@ -91,7 +116,7 @@ const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefi
   const lemma = token.lemma;
   if (!CONTENT.has(token.pos) || token.reading === undefined || lemma === undefined || !JAPANESE_WORD.test(lemma) || skip.has(lemma)) return undefined;
   const reading = lemmaReading(token.surface, lemma, token.reading);
-  if (reading === undefined || [...reading].length < MIN_READING || skip.has(reading) || isCutFromKatakana(word)) return undefined;
+  if (reading === undefined || [...reading].length < MIN_READING || skip.has(reading) || isCutFromKatakana(word) || isCopulaReadAsVerb(word)) return undefined;
   return `${token.pos}|${useOf(word, idioms)}|${reading}`;
 };
 
@@ -102,22 +127,28 @@ const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[
     const key = readingKeyOf({ token, previous: tokens[at - 1], before: tokens[at - 2] }, skips);
     const local = token.span.start - sentence.span.start;
     if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
-    return [{ key, spelling: token.lemma, sentence, offset: token.span.start }];
+    const next = tokens[at + 1];
+    const compoundHead = token.pos === "NOUN" && next?.pos === "NOUN" && isTouching(token, next);
+    return [{ key, spelling: token.lemma, sentence, offset: token.span.start, compoundHead }];
   });
 };
 
 /**
  * Same reading is not yet same word: 書く and 描く are both カク. Spellings meet only when they keep the same kanji (引っ越し, 引越し)
  * or one is all kana. A kana spelling joins the kanji one only when the reading has a single kanji spelling in the document;
- * with two (橋 and 箸 beside はし) it cannot say which, and is left out.
+ * with two (橋 and 箸 beside はし) it cannot say which, and is left out. Official Japanese drops okurigana at the head of a compound
+ * (取扱事業者 beside 個人情報の取扱い), so where the document writes a word both ways, its compound heads are compared apart.
  */
 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 apart = spellings.some((spelling) => dropsOkurigana(spelling, spellings)) ? "|compound" : "";
     return group.flatMap((word): Placed[] => {
       const own = kanjiSkeleton(word.spelling);
       if (own === "" && skeletons.length > 1) return [];
-      return [{ ...word, key: `${word.key}|${own === "" ? (skeletons[0] ?? "") : own}` }];
+      const use = word.compoundHead === true ? apart : "";
+      return [{ ...word, key: `${word.key}|${own === "" ? (skeletons[0] ?? "") : own}${use}` }];
     });
   });
 
@@ -143,12 +174,6 @@ const latinSpelling = (word: string): string =>
     .map((part) => part.charAt(0).toLowerCase() + part.slice(1))
     .join("-");
 
-/** A word joined to a dot, an at sign or a slash is part of an address or a file name (github.com, user@example), spelled as it must be. */
-const ADDRESS_NEIGHBOUR = /[.@/\\_]/u;
-
-const isPartOfAddress = (text: string, start: number, end: number): boolean =>
-  ADDRESS_NEIGHBOUR.test(text.charAt(start - 1)) || (ADDRESS_NEIGHBOUR.test(text.charAt(end)) && /\w/u.test(text.charAt(end + 1)));
-
 /**
  * Latin words keyed without hyphens and case (e-mail and email, GitHub and Github). A word in capitals only (TEAMS, MAY) is
  * emphasis or an acronym, not a spelling of the word, and is left out; so are a name in capitals with an ending (SENDs) and

package/src/detectors/orthography.ts

@@ -4,6 +4,7 @@ import { escapeRegExp, latinBoundaries, occurrencesOutside, type Boundary, type
 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";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -35,12 +36,13 @@ const digitBeside = (boundary: Boundary): number => {
 
 /**
  * 文書全体で一度だけ読むもの（number-name.ts の NameContext に加えて）。calendar は日付・時刻の単位、
- * divisions は「第1節」のように「第」と番号の後ろに書く区切りの語。
+ * divisions は「第1節」のように「第」と番号の後ろに書く区切りの語、floors は階・部屋の番号を読む語（5階、201号室、地下 1階）。
  */
 type NumberContext = NameContext & {
   readonly calendar: CalendarUnits;
   readonly divisions: ReadonlySet<string>;
   readonly itemNumbers: ReadonlySet<string>;
+  readonly floors: FloorWords;
 };
 
 /** 文頭の項目の番号の後ろと見る境目の位置の上限。番号は短く文の頭にあるので、これより後ろの境目は番号の後ろではない。長い文で文頭からの切り出しを繰り返さない。 */
@@ -71,6 +73,7 @@ const calendarStarts = (sentence: Sentence, units: CalendarUnits): ReadonlySet<n
 /**
  * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目、文頭の項目の番号（「一 JIS」）の後ろの境目は、空け方の好みではないので数えない。
  * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。
+ * 「本社 5階」のように名前の後ろに空白で区切った階・部屋の番号の前の空白も、所在の組の区切りなので数えない（location-part.ts）。
  */
 const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlySet<number>): boolean => {
   if (followsItemNumber(sentence.text, boundary, context.itemNumbers)) return false;
@@ -79,6 +82,7 @@ const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContex
   const run = digitRunAround(sentence.text, digitBeside(boundary));
   if (run === undefined) return true;
   if (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);
 };
 
@@ -145,6 +149,7 @@ export const latinSpacing: Detector = (doc, options): Finding[] => {
     calendar: calendarUnitsOf(doc),
     divisions: labelsAt(doc, "after"),
     itemNumbers: numberedItems(patternList(doc, "item-number"), doc.prose ?? doc.source),
+    floors: { units: patternsOf(doc, "floor-unit"), levels: patternsOf(doc, "floor-level") },
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);

package/src/detectors/parameter-table.ts

@@ -0,0 +1,17 @@
+// parameter-table-mismatch: a parameter table that names a parameter the signature above it does not take, or leaves out
+// one it does (parameter-table.ts). The header words of a parameter table come from the parameter-header lexicon.
+import { quoteAt } from "./structure-tree.ts";
+import { parameterSlips } from "../parameter-table.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+export const parameterTable: Detector = (doc): Finding[] => {
+  const headers = new Set((doc.lexicons["parameter-header"] ?? []).map((entry) => entry.pattern.toLowerCase()));
+  return parameterSlips(doc.source, headers).map((slip) => ({
+    rule: "parameter-table-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.offset),
+    values: { name: slip.name, function: slip.fn, side: slip.side, offset: slip.offset },
+  }));
+};

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

package/src/detectors/phone-number-variant.ts

@@ -0,0 +1,18 @@
+// phone-number-variant: one phone number written with two neighbouring digits swapped somewhere else in the document,
+// after a label of the same kind (phone-numbers.ts).
+import { labelledPhoneNumbers, phoneVariants } from "../phone-numbers.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+export const phoneNumberVariant: Detector = (doc, options): Finding[] => {
+  const labels = options.lexicon ?? [];
+  if (labels.length === 0) return [];
+  return phoneVariants(labelledPhoneNumbers(doc.prose ?? doc.source, labels)).map(({ number, other }) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, number.offset),
+    values: { written: number.written, other: other.written, offset: number.offset },
+  }));
+};

package/src/detectors/prerequisite-order.ts

@@ -0,0 +1,35 @@
+// prerequisite-after-step: a sentence opening with a prerequisite (Before you begin, 作業を始める前に) after the numbered
+// steps of its own section (prerequisite-order.ts).
+import { quoteAt } from "./structure-tree.ts";
+import { latePrerequisites } from "../prerequisite-order.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const ORDERED_ITEM = /^\s*\d{1,3}[.)]\s/u;
+/** A numbered list needs this many steps to be a procedure. */
+const MIN_STEPS = 3;
+
+const QUOTED_LINE = /^[ \t]*>/u;
+
+/** Whether a list stands in a block quote: a quoted procedure is someone else's, not the document's steps. */
+const isQuoted = (source: string, start: number): boolean => QUOTED_LINE.test(source.slice(source.lastIndexOf("\n", start - 1) + 1, start + 1));
+
+const proceduresOf = (doc: ProseDocument): { start: number; end: number }[] =>
+  doc.lists
+    .filter((list) => list.itemSpans.length >= MIN_STEPS && ORDERED_ITEM.test(doc.source.slice(list.span.start, list.span.end)))
+    .filter((list) => !isQuoted(doc.source, list.span.start))
+    .map((list) => ({ start: list.span.start, end: list.span.end }));
+
+export const prerequisiteOrder: Detector = (doc): Finding[] => {
+  const openers = (doc.lexicons["prerequisite-opener"] ?? []).map((entry) => entry.pattern);
+  if (openers.length === 0) return [];
+  const sections = doc.sections.map((section) => ({ start: section.span.start, end: section.span.end }));
+  const sentences = doc.sentences.map((sentence) => ({ start: sentence.span.start, end: sentence.span.end, text: sentence.text }));
+  return latePrerequisites(sections, proceduresOf(doc), sentences, openers).map((sentence) => ({
+    rule: "prerequisite-after-step",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, sentence.start),
+    values: { offset: sentence.start },
+  }));
+};

package/src/detectors/quote-unnamed-speaker.ts

@@ -0,0 +1,19 @@
+// quote-unnamed-speaker: a quotation given to a role with no name (業界のアナリストは「…」と述べた, "…," said an analyst).
+// The decision is in unnamed-speaker.ts.
+import { speakerWords, unnamedSpeakerQuotes } from "../unnamed-speaker.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+export const quoteUnnamedSpeaker: Detector = (doc, options): Finding[] => {
+  const words = speakerWords(options.lexicon ?? [], doc.lexicons["quote-attribution"] ?? []);
+  return doc.paragraphs
+    .flatMap((paragraph) => paragraph.sentences)
+    .flatMap((sentence) => unnamedSpeakerQuotes({ start: sentence.span.start, text: sentence.text }, words))
+    .map((hit) => ({
+      rule: "quote-unnamed-speaker",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: hit.quote,
+      values: { quote: hit.quote, speaker: hit.speaker, offset: hit.offset },
+    }));
+};