chaffjs 0.27.1 → 0.29.0

package/src/detectors/number-word-figure.ts

@@ -0,0 +1,43 @@
+// number-word-figure-mismatch: a number in words and its figure in brackets disagree (structure/number-word-figure.ts).
+// The number words are the lexicon number-word; the marks around the figure are currency-notation's and the unit words of
+// number-word; the words of scale inside the bracket ($5 million) are amount-multiplier's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { wordFigureSlips, type NumberVocabulary, type NumberWord, type NumberWordKind } from "../structure/number-word-figure.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const KINDS: readonly NumberWordKind[] = ["digit", "place", "scale", "joiner", "lead", "unit"];
+
+const numberWordsOf = (doc: ProseDocument): NumberWord[] =>
+  (doc.lexicons["number-word"] ?? []).flatMap((entry) => {
+    const kind = KINDS.find((candidate) => candidate === entry.group);
+    return kind === undefined ? [] : [{ word: entry.pattern, kind, value: entry.weight ?? 0 }];
+  });
+
+export const vocabularyOf = (doc: ProseDocument): NumberVocabulary => {
+  const words = numberWordsOf(doc);
+  const currencies = doc.lexicons["currency-notation"] ?? [];
+  const units = words.filter((word) => word.kind === "unit").map((word) => word.word);
+  return {
+    words,
+    marksBefore: currencies.filter((entry) => entry.position === "before").map((entry) => entry.pattern),
+    marksAfter: [...currencies.filter((entry) => entry.position === "after").map((entry) => entry.pattern), ...units],
+    multipliers: (doc.lexicons["amount-multiplier"] ?? []).flatMap((entry) =>
+      entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }],
+    ),
+  };
+};
+
+const NUMBER_FORMAT = new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 });
+
+export const numberWordFigure: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return wordFigureSlips(text, vocabularyOf(doc)).map((slip) => ({
+    rule: "number-word-figure-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, slip.offset, slip.end),
+    values: { written: slip.written, words: NUMBER_FORMAT.format(slip.words), figure: NUMBER_FORMAT.format(slip.figure), offset: slip.offset },
+  }));
+};

package/src/detectors/obligation-without-deadline.ts

@@ -0,0 +1,192 @@
+// A duty that happens at a point in time (pay, deliver, return, notify; 支払う, 提出する, 通知する) written with no time at
+// all, in a contract that gives most of its other duties a limit: by when must it be done? The drafter decides whether
+// duties carry limits, so only the minority in one document is pointed at, as vague-deadline does. A sentence holding
+// a vague limit (promptly) is vague-deadline's; one stating an amount (pays a fee of $9,000) sets a price, and its
+// timing is another clause's. The words come from the language package's word lists: timed-duty (the act),
+// duty-marker (shall, will), duty-ending (う, するものとする: what may follow a Japanese act at the sentence end),
+// stated-deadline (by the, までに) with concrete-deadline and vague-deadline, deadline-permission and currency-notation. Pure.
+import { quoteAt } from "./structure-tree.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { grantsRight, statesConcrete, vagueIn } from "./vague-deadline.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
+
+export type UntimedDuty = { readonly offset: number; readonly act: string };
+
+/** sameLine: the sentence goes on the line of the one before it (no line break between them). */
+type Text = { readonly start: number; readonly text: string; readonly sameLine?: boolean };
+
+/** What the word lists give the decision. */
+export type DutyWords = {
+  readonly acts: readonly string[];
+  readonly markers: readonly string[];
+  /** Words that, between the marker and the act, make the duty one not to act (will not submit). */
+  readonly negations: readonly string[];
+  readonly endings: readonly string[];
+  /** Phrases or frames that give a sentence a limit: concrete-deadline and stated-deadline. */
+  readonly limits: readonly string[];
+  /** Words that, where they stand, are no limit though a limit's words are in them (解除の日までの委託料: までの). */
+  readonly notLimits: readonly string[];
+  readonly vague: readonly string[];
+  /** Words that send the reader to other terms for how the act is done (according to the terms in the Order Form). */
+  readonly deferrals: readonly string[];
+  readonly permissions: readonly LexiconEntry[];
+  readonly currencies: readonly LexiconEntry[];
+};
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const DIGIT = /\p{Nd}/u;
+const SENTENCE_MARKS = new Set(["。", "．", ".", "!", "?", "！", "？", ";", ":"]);
+/** How many words an aside between the duty marker and the act may hold: "shall, at its option, return". */
+const MARKER_REACH_WORDS = 4;
+/** How far before an amount's trailing mark its number may end (88万円, 1,000 円). */
+const AMOUNT_REACH = 3;
+
+const withoutEnding = (text: string): string => {
+  const chars = [...text.trimEnd()];
+  const last = chars.findLastIndex((char) => !SENTENCE_MARKS.has(char) && char.trim() !== "");
+  return chars.slice(0, last + 1).join("");
+};
+
+const latinWords = (lower: string): { readonly word: string; readonly at: number }[] =>
+  [...lower.matchAll(/[\p{L}']+/gu)].map((match) => ({ word: match[0], at: match.index }));
+
+/** The act a Latin-script duty binds: an act word within reach after a duty marker (shall return, will notify). */
+const latinActAt = (lower: string, words: DutyWords): { readonly act: string; readonly at: number } | undefined => {
+  const tokens = latinWords(lower);
+  const markerWords = words.markers.map((marker) => marker.toLowerCase().split(/\s+/u));
+  const markerEnds = tokens.flatMap((_, index) =>
+    markerWords.filter((parts) => parts.every((part, offset) => tokens[index + offset]?.word === part)).map((parts) => index + parts.length),
+  );
+  const acts = new Set(words.acts.map((act) => act.toLowerCase()));
+  const negations = new Set(words.negations.map((word) => word.toLowerCase()));
+  return markerEnds
+    .flatMap((end) => {
+      const reach = tokens.slice(end, end + MARKER_REACH_WORDS);
+      const act = reach.findIndex((token) => acts.has(token.word));
+      const found = reach[act];
+      const marker = tokens[end - 1];
+      if (found === undefined || marker === undefined || reach.slice(0, act).some((token) => negations.has(token.word))) return [];
+      // The act is the verb right after the marker, or after an aside set off by a comma ("shall, at its option, return");
+      // a later act word is an object ("shall send each invoice").
+      const aside = lower
+        .slice(marker.at + marker.word.length, found.at)
+        .trimStart()
+        .startsWith(",");
+      return act === 0 || aside ? [found] : [];
+    })
+    .map((token) => ({ act: token.word, at: token.at }))[0];
+};
+
+/** The act a duty written as the sentence's last predicate binds (支払う, 通知するものとする, 通知します). */
+const endingActAt = (text: string, words: DutyWords): { readonly act: string; readonly at: number } | undefined => {
+  const ending = withoutEnding(text);
+  const act = words.acts.find((stem) => stem !== "" && words.endings.some((tail) => ending.endsWith(`${stem}${tail}`)));
+  if (act === undefined) return undefined;
+  return { act, at: ending.lastIndexOf(act) };
+};
+
+const actIn = (text: string, words: DutyWords): { readonly act: string; readonly at: number } | undefined =>
+  words.acts.some((act) => LATIN.test(act)) ? latinActAt(text.toLowerCase(), words) : endingActAt(text, words);
+
+/** An amount (¥1,000, 1,000円, $9,000) in the sentence: it sets what is paid, and when is another clause's. */
+export const statesAmount = (text: string, currencies: readonly LexiconEntry[]): boolean =>
+  currencies
+    .filter((entry) => entry.pattern !== "")
+    .some((entry) => {
+      const parts = text.split(entry.pattern);
+      return parts.slice(1).some((after, index) => {
+        const before = parts[index] ?? "";
+        return entry.position === "before" ? DIGIT.test(after.trimStart().charAt(0)) : DIGIT.test(before.trimEnd().slice(-AMOUNT_REACH));
+      });
+    });
+
+const isWordStart = (text: string, at: number): boolean => !LETTER.test(text.charAt(at - 1));
+
+/** The sentence with the words that are no limit blanked out, so that a limit's words inside them are not read. */
+const withoutNotLimits = (text: Text, notLimits: readonly string[]): Text => ({
+  start: text.start,
+  text: notLimits.filter((word) => word !== "").reduce((masked, word) => masked.replaceAll(word, " ".repeat(word.length)), text.text),
+});
+
+const FRAME = "…";
+
+/** A phrase in the sentence; a Latin one only as whole words (by the, not by their). */
+const phraseIn = (text: string, phrase: string): boolean => {
+  const lower = text.toLowerCase();
+  const wanted = phrase.toLowerCase().trim();
+  if (wanted === "") return false;
+  if (!LATIN.test(wanted)) return lower.includes(wanted);
+  return [...lower.matchAll(new RegExp(escapeRegExp(wanted), "gu"))].some(
+    (match) => !LETTER.test(lower.charAt(match.index - 1)) && !LETTER.test(lower.charAt(match.index + wanted.length)),
+  );
+};
+
+/** A limit in the sentence: a frame (within … days) or a phrase (by the, までに), outside the words that are no limit. */
+const statesLimit = (text: Text, words: DutyWords): boolean => {
+  const masked = withoutNotLimits(text, words.notLimits);
+  const frames = words.limits.filter((limit) => limit.includes(FRAME));
+  return statesConcrete(masked, frames) || words.limits.some((limit) => !limit.includes(FRAME) && phraseIn(masked.text, limit));
+};
+
+const limited = (text: Text, words: DutyWords): boolean => statesLimit(text, words) || vagueIn(text, words.vague).length > 0;
+
+/** For each sentence, the index after the last sentence on its line: the time of a duty often follows it (Fees are due within 30 days). */
+const lineEnds = (texts: readonly Text[]): number[] => {
+  const ends: number[] = [];
+  texts.reduceRight((after, _text, index) => {
+    const end = texts[index + 1]?.sameLine === true ? after : index + 1;
+    ends[index] = end;
+    return end;
+  }, texts.length);
+  return ends;
+};
+
+/**
+ * Each duty to act at a point in time whose sentence, and the rest of whose line, states no limit, holds no vague one, grants no right and states
+ * no amount, when more sentences of the document state a limit than hold such a duty: these duties are then the
+ * document's minority.
+ */
+export const untimedDuties = (texts: readonly Text[], words: DutyWords): UntimedDuty[] => {
+  const ends = lineEnds(texts);
+  const found = texts.flatMap((text, index) => {
+    const line = texts.slice(index, ends[index]);
+    if (line.some((later) => limited(later, words) || words.deferrals.some((deferral) => phraseIn(later.text, deferral)))) return [];
+    if (grantsRight(text, words.permissions) || statesAmount(text.text, words.currencies)) return [];
+    const act = actIn(text.text, words);
+    if (act === undefined || (LATIN.test(act.act) && !isWordStart(text.text, act.at))) return [];
+    return [{ offset: text.start + act.at, act: text.text.slice(act.at, act.at + act.act.length) }];
+  });
+  const limitedSentences = texts.filter((text) => statesLimit(text, words)).length;
+  return limitedSentences > found.length ? found : [];
+};
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+export const obligationWithoutDeadline: Detector = (doc): Finding[] =>
+  untimedDuties(
+    doc.sentences.map((sentence, index) => ({
+      start: sentence.span.start,
+      text: sentence.text,
+      sameLine: index > 0 && !doc.source.slice(doc.sentences[index - 1]?.span.end ?? 0, sentence.span.start).includes("\n"),
+    })),
+    {
+      acts: patternsOf(doc, "timed-duty"),
+      markers: patternsOf(doc, "duty-marker"),
+      negations: patternsOf(doc, "duty-negation"),
+      endings: patternsOf(doc, "duty-ending"),
+      limits: [...patternsOf(doc, "concrete-deadline"), ...patternsOf(doc, "stated-deadline")],
+      notLimits: patternsOf(doc, "stated-deadline-not"),
+      vague: patternsOf(doc, "vague-deadline"),
+      deferrals: patternsOf(doc, "duty-terms-elsewhere"),
+      permissions: doc.lexicons["deadline-permission"] ?? [],
+      currencies: doc.lexicons["currency-notation"] ?? [],
+    },
+  ).map((duty) => ({
+    rule: "obligation-without-deadline",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, duty.offset),
+    values: { word: duty.act, offset: duty.offset },
+  }));

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