chaffjs 0.29.0 → 0.30.0

package/src/derived/working-hours.ts

@@ -0,0 +1,97 @@
+import type { Span } from "../plugin.ts";
+import { dayShiftOf, SECONDS_PER_DAY, withoutDayShiftBefore, type Mark, type TimeSpan, type TimeWords } from "../structure/time-marks.ts";
+import { labelOf, mentionsIn, readScopes, within, type TimeLength } from "./time-lengths.ts";
+
+/**
+ * Working hours: the stated total (実働8時間, 8 hours a day) against the end minus the start minus the break
+ * (9:00〜17:30、休憩1時間 is 7.5 hours). Read in one line, or in a list whose items say it together, holding exactly one
+ * range of two times, one break with its length and one total, and no other length. A range across midnight is read
+ * only when the end carries a next-day mark (22:00〜翌7:00). Pure.
+ */
+export type WorkingHoursWords = {
+  /** What stands alone between the two times of a range (〜, to, から). */
+  readonly joiners: readonly string[];
+  readonly dayShifts: readonly Mark[];
+  readonly breaks: readonly Mark[];
+  readonly totals: readonly Mark[];
+  readonly approximate: readonly Mark[];
+};
+
+export type WorkingHoursMismatch = {
+  readonly start: Span;
+  readonly end: Span;
+  readonly break: Span;
+  readonly total: Span;
+  /** The total the times and the break give, in minutes. */
+  readonly expected: number;
+};
+
+type ClockRange = Span & { readonly from: Span; readonly to: Span; readonly minutes: number | undefined };
+
+const SECONDS_PER_MINUTE = 60;
+
+const keyOf = (text: string): string => text.normalize("NFKC").trim().toLowerCase().replace(/\s+/gu, " ");
+
+const timeWordsOf = (words: WorkingHoursWords): TimeWords => ({ legs: [], columns: [], dayShifts: words.dayShifts, zones: [] });
+
+/** The minutes from one time to the other, the end a day later when it carries a next-day mark. */
+const minutesOf = (text: string, from: TimeSpan, to: TimeSpan, words: TimeWords): number | undefined => {
+  const shift = dayShiftOf(text.slice(from.end, to.start), text, to.end, words);
+  const seconds = to.seconds + Math.max(0, shift) * SECONDS_PER_DAY - from.seconds;
+  return seconds > 0 ? seconds / SECONDS_PER_MINUTE : undefined;
+};
+
+/** Two times written one after the other with only a joiner between them (9:00〜17:30, 9 a.m. to 5:30 p.m.). */
+export const clockRanges = (text: string, times: readonly TimeSpan[], words: WorkingHoursWords): ClockRange[] => {
+  const joiners = new Set(words.joiners.map(keyOf));
+  const timeWords = timeWordsOf(words);
+  return times.flatMap((from, index): ClockRange[] => {
+    const to = times[index + 1];
+    if (to === undefined || !joiners.has(keyOf(withoutDayShiftBefore(text.slice(from.end, to.start), timeWords)))) return [];
+    return [{ start: from.start, end: to.end, from, to, minutes: minutesOf(text, from, to, timeWords) }];
+  });
+};
+
+const isApproximate = (text: string, length: Span, words: WorkingHoursWords): boolean => labelOf(text, length, words.approximate) !== undefined;
+
+type Labeled = { readonly length: TimeLength; readonly label: Span };
+
+const labeled = (text: string, lengths: readonly TimeLength[], marks: readonly Mark[]): Labeled[] =>
+  lengths.flatMap((length) => {
+    const label = labelOf(text, length, marks);
+    return label === undefined ? [] : [{ length, label }];
+  });
+
+/** The one statement in scope, or undefined when the scope does not hold exactly one. */
+const statementIn = (text: string, scope: Span, ranges: readonly ClockRange[], lengths: readonly TimeLength[], words: WorkingHoursWords) => {
+  const inRanges = ranges.filter((range) => within(range, scope));
+  const inLengths = lengths.filter((length) => within(length, scope));
+  const breaks = labeled(text, inLengths, words.breaks);
+  const totals = labeled(text, inLengths, words.totals);
+  const [range, breakLength, total] = [inRanges[0], breaks[0], totals[0]];
+  if (inRanges.length !== 1 || breaks.length !== 1 || totals.length !== 1 || inLengths.length !== 2) return undefined;
+  if (range?.minutes === undefined || breakLength === undefined || total === undefined || breakLength.length === total.length) return undefined;
+  const label = breakLength.label;
+  const unexplained = mentionsIn(text, scope, words.breaks).some((mention) => mention.end <= label.start || mention.start >= label.end);
+  if (unexplained || isApproximate(text, breakLength.length, words) || isApproximate(text, total.length, words)) return undefined;
+  return { range: { ...range, minutes: range.minutes }, breakLength: breakLength.length, total: total.length };
+};
+
+/** Working hours whose stated total is not the end minus the start minus the break. */
+export const workingHoursMismatches = (
+  text: string,
+  source: string,
+  sentences: readonly Span[],
+  times: readonly TimeSpan[],
+  lengths: readonly TimeLength[],
+  words: WorkingHoursWords,
+): WorkingHoursMismatch[] => {
+  const ranges = clockRanges(text, times, words);
+  return readScopes(text, source, { sentences, times }, (scope) => statementIn(text, scope, ranges, lengths, words)).flatMap(
+    ({ range, breakLength, total }) => {
+      const expected = range.minutes - breakLength.minutes;
+      if (expected <= 0 || expected === total.minutes) return [];
+      return [{ start: range.from, end: range.to, break: breakLength, total, expected }];
+    },
+  );
+};

package/src/detectors/acronym-expansion.ts

@@ -292,10 +292,65 @@ const proseLines = (lines: readonly string[]): string[] => {
   return withoutFences(lines.map((line, index) => (index < skipped || INDENTED.test(line) ? "" : line)));
 };
 
-/** 用語集の見出し語として、すぐ後ろに名前を書いた略語。 */
+/**
+ * 同じ書き方の見出し語が、名前で確かめられてこれだけある文書は、その書き方の用語集。用語集では、見出し語の後ろの段落はどれも定義なので、
+ * 名前の文字が揃わない項目（ADVIS: In hydrologic terms, a program…、AMVER: Automated Mutual Assistance Vessel Rescue System）も
+ * 説明済みと読む。書き方ごとに数えるので、名前を添えた箇条書きが並ぶ文書でも、略語だけの行（PDF、### MATLAB）は定義の見出しと読まない。
+ */
+const GLOSSARY_ENTRIES = 5;
+
+/**
+ * 見出し語の行。略語 1 つか、/ で並べた略語（AMVER/SEAS）。前に 1 文字の語（A AMS）を置いてもよい。空白で並べた大文字の語
+ * （SEE ALSO、XYZ QRS）は見出しや略語の並びで、見出し語ではない。
+ */
+const HEADWORD_WORD = String.raw`[A-Z][A-Z&-]*[A-Z]`;
+const HEADWORD_LINE = new RegExp(String.raw`^(?:#{1,6}\s+)?(?:[A-Z]\s)?(?<words>${HEADWORD_WORD}(?:/${HEADWORD_WORD})*)\s*(?<colon>[:：])?(?:\s+#+)?$`, "u");
+const HEADING_LINE = /^#{1,6}\s/u;
+
+/** 定義の段落。小文字の語を含み（次の見出し語ではなく）、見出しでもない行。 */
+const isDefinitionLine = (line: string): boolean => /\p{Ll}/u.test(line) && !HEADING_LINE.test(line);
+
+/** 用語集の、見出し語だけの行と、その次の空でない行が定義の段落のもの。 */
+const glossaryLineTerms = (lines: readonly string[], index: number): string[] => {
+  const line = (lines[index] ?? "").trim();
+  const groups = HEADWORD_LINE.exec(line.replaceAll(STRONG, ""))?.groups;
+  if (groups?.["words"] === undefined || (groups["colon"] !== undefined && !MARKED_LINE.test(line))) return [];
+  const next = lines.slice(index + 1, index + 1 + NEXT_LINE_REACH).find((candidate) => candidate.trim() !== "");
+  return next !== undefined && isDefinitionLine(next.trim()) ? groups["words"].split("/") : [];
+};
+
+/** 用語集の、印を付けた見出し語と区切りの後ろの定義（**ADVIS**: In hydrologic terms…、- ADVIS — a program…）。 */
+const glossaryLeadTerm = (line: string): string[] => {
+  const lead = TERM_LEAD.exec(line.trim());
+  const term = lead?.groups?.["strongTerm"] ?? lead?.groups?.["term"];
+  return term !== undefined && /\p{Ll}/u.test(lead?.groups?.["rest"] ?? "") ? [term] : [];
+};
+
+type EntryForm = {
+  readonly named: (lines: readonly string[], index: number) => string[];
+  readonly defined: (lines: readonly string[], index: number) => string[];
+};
+
+/** 見出し語の書き方。行だけの見出し語と、印を付けた見出し語の後ろの名前。表は隣のセルの名前だけで読む。 */
+const ENTRY_FORMS: readonly EntryForm[] = [
+  { named: (lines, index) => (TABLE_ROW.test(lines[index] ?? "") ? [] : lineTerm(lines, index)), defined: glossaryLineTerms },
+  {
+    named: (lines, index) => (TABLE_ROW.test(lines[index] ?? "") ? [] : leadTerm(lines[index] ?? "")),
+    defined: (lines, index) => glossaryLeadTerm(lines[index] ?? ""),
+  },
+  { named: (lines, index) => (TABLE_ROW.test(lines[index] ?? "") ? tableTerms(lines[index] ?? "") : []), defined: () => [] },
+];
+
+/** 一つの書き方で見出し語と読む略語。その書き方の用語集なら、名前でない定義を書いたものも。 */
+const formTerms = (lines: readonly string[], form: EntryForm): string[] => {
+  const named = lines.flatMap((_, index) => form.named(lines, index));
+  return new Set(named).size < GLOSSARY_ENTRIES ? named : [...named, ...lines.flatMap((_, index) => form.defined(lines, index))];
+};
+
+/** 用語集の見出し語として、すぐ後ろに名前を書いた略語。用語集と読める書き方では、名前でなくても定義を書いた略語。 */
 export const termEntryAcronyms = (source: string): ReadonlySet<string> => {
   const lines = proseLines(source.split(/\r?\n/u));
-  return new Set(lines.flatMap((line, index) => (TABLE_ROW.test(line) ? tableTerms(line) : [...lineTerm(lines, index), ...leadTerm(line)])));
+  return new Set(ENTRY_FORMS.flatMap((form) => formTerms(lines, form)));
 };
 
 export type ExpandedAt = (body: string, acronym: string, at: number) => boolean;

package/src/detectors/capitalised-term.ts

@@ -0,0 +1,147 @@
+// A term written like the document's defined terms, capitalised inside a sentence (its Affiliates, disclose Proprietary
+// Data), that the document defines nowhere. Read only where the document defines its terms with a defining word
+// (MIN_DEFINED of them: "X" means, (the "X")). A capitalised run is also the name of a law, a body, a place, a party or a
+// part of the document, so every name the language package lists is left, and so is every run set apart by markup (a
+// heading, a link, bold, an HTML element, a table row, a list item's label). Pure.
+import { escapeRegExp } from "../orthography.ts";
+import type { Span, Token } from "../plugin.ts";
+
+export type CapitalisedTerm = { readonly offset: number; readonly term: string };
+
+/** The word lists the decision reads, matched as written. */
+export type CapitalisedWords = {
+  /** A run holding one of these is a name (Act, Policy, Inc, California, Monday, Supplier), not a term. */
+  readonly names: readonly string[];
+  /** A run opening with one of these points at a part of the document (Section 4, Schedule A). */
+  readonly divisions: readonly string[];
+  /** Small words inside one name (Statement of Work, Trials and Betas). */
+  readonly joiners: readonly string[];
+};
+
+/** A term the document defines; bare is a definition with no defining word (("GPC")), which names more than it defines. */
+export type Defined = { readonly term: string; readonly bare?: boolean };
+
+export type CapitalisedInput = {
+  readonly source: string;
+  /** The text a reader sees (the source without link destinations): where a lower-case use counts. */
+  readonly readable: string;
+  readonly sentences: readonly (readonly Token[])[];
+  readonly defined: readonly Defined[];
+  /** Words set in quotes or bold anywhere ("Account" represents …, **Security Measures**): named on purpose. */
+  readonly named: readonly string[];
+  /** Spans set apart by markup: headings, links, bold, HTML elements, table rows, list items' labels. */
+  readonly marked: readonly Span[];
+  readonly words: CapitalisedWords;
+};
+
+/** Fewer definitions than this, and capitals are the document's style, not its way of naming terms. */
+const MIN_DEFINED = 2;
+const CAPITALISED = /^\p{Lu}\p{Ll}+(?:['’]\p{Ll}+)?$/u;
+const ACRONYM = /^\p{Lu}{2,}$/u;
+const DEFINED_FORM = /^\p{Lu}/u;
+const LOWER_WORD = /^\p{Ll}+$/u;
+const HYPHEN = "-";
+
+const isCapitalised = (token: Token | undefined): boolean => token !== undefined && CAPITALISED.test(token.surface);
+/** A word that carries a run on once it has started: a capitalised word or an acronym (Commercial AI System). */
+const continues = (token: Token | undefined): boolean => isCapitalised(token) || (token !== undefined && ACRONYM.test(token.surface));
+const adjacent = (left: Token, right: Token): boolean => right.span.start - left.span.end <= 1;
+const touching = (left: Token, right: Token): boolean => right.span.start === left.span.end;
+
+/** The forms one term is written in: lower case, its last word as written and singular (Policies, Policy; Viruses, Virus). */
+const formsOf = (term: string): string[] => {
+  const words = term.toLowerCase().split(/[\s-]+/u);
+  const head = words.slice(0, -1).join(" ");
+  const last = words.at(-1) ?? "";
+  const lasts = [last, last.replace(/ies$/u, "y"), last.replace(/es$/u, ""), last.replace(/(?<!s)s$/u, "")];
+  return lasts.map((form) => (head === "" ? form : `${head} ${form}`));
+};
+
+/** How many tokens the capitalised run starting at index takes: words that continue it, and a joiner or hyphen between two. */
+const runLength = (tokens: readonly Token[], index: number, joiners: ReadonlySet<string>): number => {
+  const word = tokens[index];
+  const next = tokens[index + 1];
+  const after = tokens[index + 2];
+  if (next === undefined || word === undefined || !adjacent(word, next)) return 1;
+  if (continues(next)) return 1 + runLength(tokens, index + 1, joiners);
+  const hyphened = next.surface === HYPHEN && touching(word, next) && after !== undefined && touching(next, after);
+  const joined = hyphened || (joiners.has(next.surface) && after !== undefined && adjacent(next, after));
+  return joined && continues(after) ? 2 + runLength(tokens, index + 2, joiners) : 1;
+};
+
+type Run = { readonly start: number; readonly end: number };
+
+/** The capitalised runs of one sentence, as [start, end) token indexes; a run never starts inside the one before. */
+const runsOf = (tokens: readonly Token[], joiners: ReadonlySet<string>): Run[] =>
+  tokens.reduce<Run[]>((runs, token, index) => {
+    if ((runs.at(-1)?.end ?? 0) > index || !isCapitalised(token)) return runs;
+    return [...runs, { start: index, end: index + runLength(tokens, index, joiners) }];
+  }, []);
+
+const inside = (offset: number, spans: readonly Span[]): boolean => spans.some((span) => span.start <= offset && offset < span.end);
+
+/** Used like a defined term: after a lower-case word, and not a modifier of a lower-case noun after it (the Premium plan). */
+const placedLikeATerm = (before: Token | undefined, after: Token | undefined): boolean =>
+  before !== undefined && LOWER_WORD.test(before.surface) && !(after !== undefined && after.pos === "NOUN" && LOWER_WORD.test(after.surface));
+
+/** Every run of whole words in a term (GitHub Service: GitHub, Service, GitHub Service). */
+const partsOf = (term: string): string[] => {
+  const words = term.split(/\s+/u);
+  return words.flatMap((_, start) => words.slice(start).map((__, length) => words.slice(start, start + length + 1).join(" ")));
+};
+
+/** The text also writes the term in lower case (your account, account settings): an ordinary word, or a screen's label. */
+const writtenInLowerCase = (text: string, term: string): boolean => {
+  const words = term
+    .toLowerCase()
+    .split(/[\s-]+/u)
+    .map(escapeRegExp)
+    .join(String.raw`[\s-]+`);
+  return new RegExp(String.raw`(?<!\p{L})${words}(?:e?s)?(?!\p{L})`, "u").test(text);
+};
+
+/**
+ * The first use of each capitalised run used inside a sentence like a defined term that names nothing the language
+ * package lists, is not set apart by markup, is never written in lower case, and neither is nor holds a defined or named
+ * term in any case.
+ */
+export const capitalisedTerms = (input: CapitalisedInput): CapitalisedTerm[] => {
+  const defining = input.defined.filter((definition) => definition.bare !== true && DEFINED_FORM.test(definition.term));
+  if (defining.length < MIN_DEFINED) return [];
+  const joiners = new Set(input.words.joiners);
+  const divisions = new Set(input.words.divisions.flatMap(formsOf));
+  const known = new Set([...input.defined.map((definition) => definition.term), ...input.named, ...input.words.names].flatMap(formsOf));
+  const isKnown = (term: string): boolean => partsOf(term).some((part) => formsOf(part).some((form) => known.has(form)));
+  const uses = input.sentences.flatMap((tokens) =>
+    runsOf(tokens, joiners).flatMap(({ start, end }): CapitalisedTerm[] => {
+      const first = tokens[start];
+      const last = tokens[end - 1];
+      if (first === undefined || last === undefined || !placedLikeATerm(tokens[start - 1], tokens[end])) return [];
+      if (inside(first.span.start, input.marked) || formsOf(first.surface).some((form) => divisions.has(form))) return [];
+      const term = input.source.slice(first.span.start, last.span.end);
+      return isKnown(term) || writtenInLowerCase(input.readable, term) ? [] : [{ offset: first.span.start, term }];
+    }),
+  );
+  return uses.filter((use, index) => uses.findIndex((other) => formsOf(other.term).some((form) => formsOf(use.term).includes(form))) === index);
+};
+
+const BOLD = /\*\*([^*\n]+)\*\*|__([^_\n]+)__/gu;
+const QUOTED = /["“]([^"“”\n]{1,80}?)[,.]?["”]/gu;
+const HTML_ELEMENT = /<([a-z][a-z0-9]*)\b[^>]*>[^<]*<\/\1>/giu;
+const TABLE_ROW = /^[ \t]*\|.*$/gmu;
+const ITEM_LABEL = /^[ \t]*(?:[*+-]|\d+[.)])[ \t]+[^:\n]{1,80}:/gmu;
+
+const spansOf = (source: string, pattern: RegExp): Span[] =>
+  [...source.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** Bold, HTML elements, table rows and list items' labels in a Markdown source: labels and cells, not running text. */
+export const setApartSpans = (source: string): Span[] => [BOLD, HTML_ELEMENT, TABLE_ROW, ITEM_LABEL].flatMap((pattern) => spansOf(source, pattern));
+
+const LINK_DESTINATION = /\]\([^)\n]*\)|<?https?:\/\/[^\s)>]+>?/gu;
+
+/** The source with link destinations and URLs blanked: the words a reader sees. */
+export const readableText = (source: string): string => source.replaceAll(LINK_DESTINATION, (destination) => " ".repeat(destination.length));
+
+/** The words set in quotes or bold anywhere in a source, without the emphasis marks. */
+export const namedWords = (source: string): string[] =>
+  [BOLD, QUOTED].flatMap((pattern) => [...source.matchAll(pattern)].map((match) => (match[1] ?? match[2] ?? "").replaceAll(/[*_]/gu, "").trim()));

package/src/detectors/date-outside-period.ts

@@ -6,10 +6,13 @@ import { quoteAt } from "./structure-tree.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
-/** 期間の語、期間の外に置く語、範囲の記号（range-connector、range-opener、range-frame の間の語）、月と曜日の名は語彙表から取る。 */
+/** 期間の語、期間の外に置く語、文書の仕事の期間の語、締め切りの語、概要の節の見出しの語、範囲の記号（range-connector、range-opener、range-frame の間の語）、月と曜日の名は語彙表から取る。 */
 const wordsOf = (doc: ProseDocument): OutsideWords => ({
   labels: patternsOf(doc, "period-label"),
+  terms: patternsOf(doc, "period-term-label"),
   asides: patternsOf(doc, "period-aside"),
+  deadlines: patternsOf(doc, "period-deadline"),
+  overviews: patternsOf(doc, "period-overview-heading"),
   connectors: [
     ...patternsOf(doc, "range-connector"),
     ...patternsOf(doc, "range-opener"),

package/src/detectors/derived-numbers.ts

@@ -15,7 +15,12 @@ import {
   type NightsMismatch,
   type StayColumnWords,
 } from "../derived/stays.ts";
-import { escapeRegExp } from "../orthography.ts";
+import { numeralCounts } from "../derived/unit-counts.ts";
+import { timeLengths, type LengthWords, type TimeLength } from "../derived/time-lengths.ts";
+import { workingHoursMismatches, type WorkingHoursMismatch } from "../derived/working-hours.ts";
+import { sessionHoursMismatches } from "../derived/session-hours.ts";
+import { clockTimes } from "../compare/clock-time.ts";
+import { secondsOf, type Mark } from "../structure/time-marks.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAt } from "./structure-tree.ts";
 
@@ -93,29 +98,18 @@ const durationsOf = (doc: ProseDocument, quantities: readonly Quantity[]): Durat
 
 const sentencesOf = (doc: ProseDocument): Span[] => doc.sentences.map((sentence) => sentence.span);
 
-const LATIN_UNIT = /^[a-z]+$/iu;
-
-/** 数字と泊数の単位（3泊、3 nights）。英字の単位は語の切れ目まで。 */
-const digitNights = (text: string, units: readonly string[]): Count[] =>
-  units.flatMap((unit) => {
-    const tail = LATIN_UNIT.test(unit) ? "(?![\\p{L}\\p{N}])" : "";
-    const pattern = new RegExp(`(?<![\\p{N}.,])(\\p{Nd}+)\\s?${escapeRegExp(unit)}${tail}`, "giu");
-    return [...text.matchAll(pattern)].map((match) => ({
-      start: match.index,
-      end: match.index + match[0].length,
-      amount: Number((match[1] ?? "").normalize("NFKC")),
-    }));
-  });
-
 /** 泊数（3泊、3 nights、three nights）。text は地の文と表（リンク先や code は読まない）。目安の泊数（最大3泊）は除く。 */
-const nightsOf = (doc: ProseDocument, text: string): Count[] => {
-  const units = patternsOf(doc, "stay-night");
-  const digits = digitNights(text, units);
-  const taken = spanIndex(digits);
+/** 数と単位（3泊、15 sessions、three nights）。 */
+const unitCountsOf = (doc: ProseDocument, text: string, units: readonly string[]): Count[] => {
+  const numerals = numeralCounts(text, units);
+  const taken = spanIndex(numerals);
   const worded = numberWordCounts(text, patternsOf(doc, "count-number"), units).filter((count) => !overlapsAny(taken, count));
-  return [...digits, ...worded].filter((count) => !isApproximate(doc, count)).toSorted((left, right) => left.start - right.start);
+  return [...numerals, ...worded].toSorted((left, right) => left.start - right.start);
 };
 
+const nightsOf = (doc: ProseDocument, text: string): Count[] =>
+  unitCountsOf(doc, text, patternsOf(doc, "stay-night")).filter((count) => !isApproximate(doc, count));
+
 const finding = (doc: ProseDocument, offset: number, values: Record<string, string | number>, variant?: string): Finding => ({
   rule: "duration-mismatch",
   severity: "warning",
@@ -143,6 +137,57 @@ const stayColumnWords = (doc: ProseDocument): StayColumnWords => ({
   units: patternsOf(doc, "stay-night"),
 });
 
+const marksOf = (doc: ProseDocument, id: string): Mark[] =>
+  (doc.lexicons[id] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position, group: entry.group }));
+
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+/** The hour and minute units of unit-time, told apart by their weight in seconds. */
+const unitsWeighing = (doc: ProseDocument, seconds: number): string[] =>
+  (doc.lexicons["unit-time"] ?? []).filter((entry) => entry.weight === seconds).map((entry) => entry.pattern);
+
+const lengthWords = (doc: ProseDocument): LengthWords => ({
+  hourUnits: unitsWeighing(doc, SECONDS_PER_HOUR),
+  minuteUnits: unitsWeighing(doc, SECONDS_PER_MINUTE),
+  halves: patternsOf(doc, "length-half"),
+  numberWords: patternsOf(doc, "count-number"),
+});
+
+const lengthsOf = (doc: ProseDocument, text: string): TimeLength[] => timeLengths(text, lengthWords(doc));
+
+const MINUTES_PER_HOUR = 60;
+const HOUR_DECIMALS = 100;
+
+const hoursOf = (minutes: number): number => Math.round((minutes / MINUTES_PER_HOUR) * HOUR_DECIMALS) / HOUR_DECIMALS;
+
+const workingHoursFinding = (doc: ProseDocument, mismatch: WorkingHoursMismatch): Finding =>
+  finding(
+    doc,
+    mismatch.total.start,
+    {
+      start: written(doc, mismatch.start),
+      end: written(doc, mismatch.end),
+      break: written(doc, mismatch.break),
+      total: written(doc, mismatch.total),
+      expected: hoursOf(mismatch.expected),
+    },
+    "working-hours",
+  );
+
+/** 始業から終業まで、休憩を除いた時間が、書いた実働と合わない。 */
+const workingHoursOf = (doc: ProseDocument, text: string): Finding[] => {
+  const times = clockTimes(text).map((time) => ({ start: time.start, end: time.end, seconds: secondsOf(time.key) }));
+  const words = {
+    joiners: patternsOf(doc, "clock-range-joiner"),
+    dayShifts: marksOf(doc, "day-shift-mark"),
+    breaks: marksOf(doc, "working-hours-break"),
+    totals: marksOf(doc, "working-hours-total"),
+    approximate: marksOf(doc, "approximate-marker"),
+  };
+  return workingHoursMismatches(text, doc.source, sentencesOf(doc), times, lengthsOf(doc, text), words).map((mismatch) => workingHoursFinding(doc, mismatch));
+};
+
 /** 始まり + 期間 ≠ 終わり。泊数が二つの日付の差と合わない。「2泊3日」の日数が泊数より一つ多くない。 */
 export const durationMismatch: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
@@ -173,7 +218,35 @@ export const durationMismatch: Detector = (doc): Finding[] => {
   const nightsDays = nightsDaysMismatches(pairs).map((mismatch) =>
     finding(doc, mismatch.days.start, { nights: written(doc, mismatch.nights), days: written(doc, mismatch.days), expected: mismatch.expected }, "nights-days"),
   );
-  return [...lengths, ...stays.map((mismatch) => nightsFinding(doc, mismatch)), ...nightsDays];
+  return [...lengths, ...stays.map((mismatch) => nightsFinding(doc, mismatch)), ...nightsDays, ...workingHoursOf(doc, proseAndTables)];
+};
+
+/** 番号の書き方（ordinal-frame）の頭の語のすぐ後ろの数。「第15回」は15番目の回で、15回ではない。 */
+const isOrdinal = (doc: ProseDocument, text: string, count: Span): boolean =>
+  patternsOf(doc, "ordinal-frame").some((frame) => {
+    const head = frame.split("{n}")[0] ?? "";
+    return head !== "" && text.slice(Math.max(0, count.start - head.length), count.start).toLowerCase() === head.toLowerCase();
+  });
+
+/** 回数 × 1回の長さが、書いた合計と合わない（90分×15回（計24時間））。 */
+export const durationProductMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const counts = unitCountsOf(doc, text, patternsOf(doc, "session-count-unit")).filter((count) => !isOrdinal(doc, text, count));
+  const words = { totals: marksOf(doc, "session-total"), approximate: marksOf(doc, "approximate-marker") };
+  return sessionHoursMismatches(text, doc.source, sentencesOf(doc), counts, lengthsOf(doc, text), words).map((mismatch) => ({
+    rule: "duration-product-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mismatch.total.start),
+    values: {
+      count: written(doc, mismatch.count),
+      length: written(doc, mismatch.length),
+      total: written(doc, mismatch.total),
+      expected: hoursOf(mismatch.expected),
+      offset: mismatch.total.start,
+    },
+  }));
 };
 
 /** 四桁の年。木が日付と読まなかった英語の年（founded in 2015、born 1980）もここで読む。 */

package/src/detectors/name-variant.ts

@@ -1,10 +1,15 @@
 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 { 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 { proseAndTablesOf } from "../table-text.ts";
+import { tableBodyCells } from "../facts/table-facts.ts";
+import { cellNamesIn, cellNameVariants, proseNamesOf } from "../table-names.ts";
 import { placeMentionsIn, placeVariants, type PlaceReader, type PlaceWord } from "../place-names.ts";
-import type { Token } from "../plugin.ts";
+import type { TableCell, Token } from "../plugin.ts";
+import { proseWithCells } from "../table-cells.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）ごとに言う。
@@ -31,7 +36,14 @@ const placeWordsOf = (doc: ProseDocument): PlaceWord[] =>
 /** 名前の頭に立たない語の品詞（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 +86,83 @@ 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)))
+  placeVariants(placeMentionsIn(proseWithCells(prose, cellsOf(doc)), placeWordsOf(doc), placeReaderOf(doc)))
     .filter(({ mention }) => !overlapsAny(reported, mention.offset, mention.surface.length))
     .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind }));
 
+/** 名前の中で比べる語の品詞。助詞や冠詞（の、of）は語の順に数えない。 */
+const CONTENT_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN", "ADJ", "NUM", "VERB"]);
+
+/** 欄の後ろの名前を切る所: 内容語でも名前の中の小さな語（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);
 };
 
+/** 表の升に書いた名前の書き分け。名前の形をした升を、本文の名前と比べる。ほかの見方がすでに指した所と重なるものは除く。 */
+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).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)];
+  return [...withPlaces, ...orderFindings(doc, prose, withPlaces)]
     .toSorted((left, right) => left.offset - right.offset)
     .map(({ offset, name, usual, kind }) => ({
       rule: "",