chaffjs 0.30.0 → 0.32.0

package/src/detectors/orthographic-variant.ts

@@ -1,18 +1,26 @@
-import type { Detector, Finding, ProseDocument, Sentence, Token } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, TableCell, Token } from "../plugin.ts";
 import { groupBy, oddSpellings, type KeyedWord, type OddSpelling } from "../spelling-variants.ts";
-import { dropsOkurigana, kanjiSkeleton, katakanaKey, lemmaReading } from "../kana-spelling.ts";
+import { dropsOkurigana, kanjiKeyAmong, katakanaKey, lemmaReading } from "../kana-spelling.ts";
 import { isKatakanaWord, stemOf } from "../long-vowel.ts";
 import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
 import { furiganaSpans } from "../furigana.ts";
 import { acronymsIn, isCapitalsNotSpelling } from "../capitals-with-small.ts";
 import { isPartOfAddress } from "./address-word.ts";
+import { wholeWordRuns, type WholeWordRun } from "../whole-word-runs.ts";
 
 /**
  * A word found in the document: where it is, which sentence it is in, its key and spelling, how it is written when that differs, and
  * whether it is written onto the noun after it (取扱事業者).
  */
-type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string; readonly compoundHead?: boolean };
+type Placed = KeyedWord & {
+  readonly sentence: Sentence;
+  readonly offset: number;
+  readonly shown?: string;
+  readonly compoundHead?: boolean;
+  /** Where a run of words ends (タイヤレバー). */
+  readonly end?: number;
+};
 
 type IsOpen = (start: number, end: number) => boolean;
 
@@ -30,6 +38,8 @@ const DISTINCT = "orthographic-variant-distinct";
 const FUKUSHI = "hiragana-fukushi";
 /** Lexicon: idioms written as noun, particle and verb (気をつける). The verb there is compared apart from the verb on its own. */
 const IDIOM = "orthographic-variant-idiom";
+/** Lexicon: words the tokenizer cuts in one spelling and not the other (お客様, お客 and さま). Each is read whole, keyed by its group. */
+const WHOLE_WORD = "orthographic-variant-whole-word";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
@@ -109,7 +119,7 @@ const isCutFromKatakana = ({ token, previous }: InContext): boolean =>
 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> };
+type Skips = { readonly skip: ReadonlySet<string>; readonly idioms: ReadonlySet<string>; readonly wholeWords: ReadonlyMap<string, string> };
 
 const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefined => {
   const { token } = word;
@@ -120,17 +130,40 @@ const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefi
   return `${token.pos}|${useOf(word, idioms)}|${reading}`;
 };
 
+/**
+ * A listed word keyed by its group, so its spellings meet however the tokenizer cut each one. Not by reading: お父様 is read
+ * オ + トウサマ and お父さま オ + チチ + サマ.
+ */
+const wholeWordOf = (
+  sentence: Sentence,
+  tokens: readonly Token[],
+  { first, last, word }: WholeWordRun,
+  isOpen: IsOpen,
+  groups: ReadonlyMap<string, string>,
+): Placed[] => {
+  const [head, tail] = [tokens[first], tokens[last]];
+  if (head === undefined || tail === undefined || !isOpen(head.span.start - sentence.span.start, tail.span.end - sentence.span.start)) return [];
+  return [{ key: `whole|${groups.get(word) ?? word}`, spelling: word, sentence, offset: head.span.start }];
+};
+
 /** Japanese words keyed by part of speech, use and the reading of the dictionary form, spelled as the dictionary form. */
 const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[] => {
   const tokens = sentence.tokens ?? [];
-  return tokens.flatMap((token, at): 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 [];
-    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 }];
-  });
+  const runs = wholeWordRuns(tokens, skips.wholeWords);
+  const inRun = new Set(runs.flatMap(({ first, last }) => Array.from({ length: last - first + 1 }, (_, extra) => first + extra)));
+  const whole = runs.flatMap((run) => wholeWordOf(sentence, tokens, run, isOpen, skips.wholeWords));
+  return [
+    ...whole,
+    ...tokens.flatMap((token, at): Placed[] => {
+      if (inRun.has(at)) return [];
+      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 [];
+      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 }];
+    }),
+  ];
 };
 
 /**
@@ -141,11 +174,12 @@ const readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[
  */
 const byKanji = (words: readonly Placed[]): Placed[] =>
   [...groupBy(words, (word) => word.key).values()].flatMap((group) => {
-    const skeletons = [...new Set(group.map((word) => kanjiSkeleton(word.spelling)).filter((skeleton) => skeleton !== ""))];
     const spellings = [...new Set(group.map((word) => word.spelling))];
+    const skeletonOf = (spelling: string): string => kanjiKeyAmong(spelling, spellings);
+    const skeletons = [...new Set(spellings.map(skeletonOf).filter((skeleton) => skeleton !== ""))];
     const apart = spellings.some((spelling) => dropsOkurigana(spelling, spellings)) ? "|compound" : "";
     return group.flatMap((word): Placed[] => {
-      const own = kanjiSkeleton(word.spelling);
+      const own = skeletonOf(word.spelling);
       if (own === "" && skeletons.length > 1) return [];
       const use = word.compoundHead === true ? apart : "";
       return [{ ...word, key: `${word.key}|${own === "" ? (skeletons[0] ?? "") : own}${use}` }];
@@ -161,6 +195,44 @@ const katakanaWords = (sentence: Sentence, isOpen: IsOpen): Placed[] =>
     return [...key].length < MIN_KATAKANA_KEY ? [] : [{ key: `kana|${key}`, spelling: stemOf(token.surface), sentence, offset: token.span.start }];
   });
 
+const isKatakanaNoun = (token: Token): boolean => token.pos === "NOUN" && isKatakanaWord(token.surface);
+
+/** Katakana nouns written onto each other (タイヤ and レバー in タイヤレバー), each run whole: one place may be cut into words another is not. */
+const katakanaRuns = (tokens: readonly Token[]): Token[][] =>
+  tokens.reduce<Token[][]>((runs, token, at) => {
+    if (!isKatakanaNoun(token)) return runs;
+    const last = runs.at(-1);
+    if (last !== undefined && isTouching(tokens[at - 1], token) && last.at(-1) === tokens[at - 1]) last.push(token);
+    else runs.push([token]);
+    return runs;
+  }, []);
+
+/**
+ * Katakana runs keyed like one katakana word, spelled as their words' stems joined: タイヤーレバー (one unknown word) meets
+ * タイヤレバー read as タイヤ and レバー, while the final ー of a word inside the run (サーバーリスト and サーバリスト) stays katakana-long-vowel's.
+ */
+const katakanaRunWords = (sentence: Sentence, isOpen: IsOpen): Placed[] =>
+  katakanaRuns(sentence.tokens ?? []).flatMap((run): Placed[] => {
+    const [first, last] = [run[0], run.at(-1)];
+    if (first === undefined || last === undefined) return [];
+    const [start, end] = [first.span.start - sentence.span.start, last.span.end - sentence.span.start];
+    const key = katakanaKey(run.map((token) => token.surface).join(""));
+    if ([...key].length < MIN_KATAKANA_KEY || !isOpen(start, end)) return [];
+    return [
+      {
+        key: `kana|${key}`,
+        spelling: run.map((token) => stemOf(token.surface)).join(""),
+        shown: run.map((token) => token.surface).join(""),
+        sentence,
+        offset: first.span.start,
+        end: last.span.end,
+      },
+    ];
+  });
+
+/** Whether a run holds a place another key already points at: the word inside it is said, not the run around it. */
+const coversOffset = (run: Placed, offset: number): boolean => offset >= run.offset && offset < (run.end ?? run.offset + 1);
+
 const LATIN_WORD = /[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*/gu;
 const LOWER = /\p{Ll}/u;
 
@@ -204,19 +276,46 @@ const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding
   values: { written: odd.word.shown ?? odd.word.spelling, other: shownUsual(words, odd), count: odd.count, of: odd.of, offset: odd.word.offset },
 });
 
+/** A cell that is one Latin word in lower case (openapi, contentType): a field name or a value, spelled by the data and not by the writer. */
+const DATA_KEY_CELL = /^\p{Ll}[A-Za-z0-9]*$/u;
+
+type Place = { readonly sentence: Sentence; readonly isOpen: IsOpen; readonly readsLatin: boolean };
+
+/** A link's brackets and where it goes (`[`, `](#contentType)`, `][ref]`). The prose hides them outside tables; a cell keeps the Markdown as written. */
+const LINK_CHROME = /\]\([^)]*\)|\]\[[^\]]*\]|\[/gu;
+
+const withoutLinkChrome = (text: string): string => text.replaceAll(LINK_CHROME, (chrome) => " ".repeat(chrome.length));
+
+/** A body cell of a table read as a sentence of its own: the prose covers tables, so a cell's words (片栗粉 in a list of ingredients) are not in the sentences. Header rows stay out. */
+const cellPlace = (cell: TableCell, names: readonly string[]): Place => {
+  const text = withoutLinkChrome(cell.text);
+  const sentence: Sentence = { span: { start: cell.start, end: cell.end }, text, tokens: cell.tokens ?? [] };
+  return { sentence, isOpen: isOpenIn(sentence, names), readsLatin: !DATA_KEY_CELL.test(text.trim()) };
+};
+
 /**
  * One word written two ways in one document (出来る and できる, 引っ越し and 引越し, ウィンドウ and ウインドウ, e-mail and email),
  * found without a list of words: the document's own words are grouped by reading or by an evened-out spelling, and the way the
  * document writes less is pointed at. No way is called right; limit is the largest share, in percent, the minority may have.
  */
 export const orthographicVariant: Detector = (doc, options): Finding[] => {
-  const skips: Skips = { skip: new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]), idioms: new Set(patternsOf(doc, IDIOM)) };
-  const placed = doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, doc.names ?? []) }));
+  const skips: Skips = {
+    skip: new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]),
+    idioms: new Set(patternsOf(doc, IDIOM)),
+    wholeWords: new Map((doc.lexicons[WHOLE_WORD] ?? []).map((entry) => [entry.pattern, entry.group ?? entry.pattern])),
+  };
+  const names = doc.names ?? [];
+  const placed: Place[] = [
+    ...doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, names), readsLatin: true })),
+    ...(doc.tableCells?.() ?? []).map((cell) => cellPlace(cell, names)),
+  ];
   const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skips)));
   const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
-  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skips.skip));
+  const runs = placed.flatMap(({ sentence, isOpen }) => katakanaRunWords(sentence, isOpen));
+  const latin = placed.flatMap(({ sentence, isOpen, readsLatin }) => (readsLatin ? latinWords(sentence, isOpen, skips.skip) : []));
   const odd = [reading, katakana, latin].flatMap((words) => oddSpellings(words, options.limit));
-  const all = [...reading, ...katakana, ...latin];
+  const oddRuns = oddSpellings(runs, options.limit).filter(({ word }) => !odd.some((other) => coversOffset(word, other.word.offset)));
+  const all = [...reading, ...katakana, ...runs, ...latin];
   // A word can be odd by its reading and by its katakana key at once; one place is said once.
-  return [...new Map(odd.map((entry) => [entry.word.offset, entry])).values()].map((entry) => findingOf(all, entry));
+  return [...new Map([...odd, ...oddRuns].map((entry) => [entry.word.offset, entry])).values()].map((entry) => findingOf(all, entry));
 };

package/src/detectors/orthography.ts

@@ -5,6 +5,8 @@ import { minorityReport } from "../spacing-minority.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStarts, type NameContext } from "../number-name.ts";
 import { isSpacedLocationPart, type FloorWords } from "../location-part.ts";
+import { isNameSeparator, type OrganizationWords } from "../name-separator.ts";
+import { addressSpans, clockTimeSpans, identifierSpans, isInsideSpan } from "../spacing-code.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -36,13 +38,15 @@ const digitBeside = (boundary: Boundary): number => {
 
 /**
  * 文書全体で一度だけ読むもの（number-name.ts の NameContext に加えて）。calendar は日付・時刻の単位、
- * divisions は「第1節」のように「第」と番号の後ろに書く区切りの語、floors は階・部屋の番号を読む語（5階、201号室、地下 1階）。
+ * divisions は「第1節」のように「第」と番号の後ろに書く区切りの語、floors は階・部屋の番号を読む語（5階、201号室、地下 1階）、
+ * organizations は組織の名前を読む語（経営企画部、株式会社）。
  */
 type NumberContext = NameContext & {
   readonly calendar: CalendarUnits;
   readonly divisions: ReadonlySet<string>;
   readonly itemNumbers: ReadonlySet<string>;
   readonly floors: FloorWords;
+  readonly organizations: OrganizationWords;
 };
 
 /** 文頭の項目の番号の後ろと見る境目の位置の上限。番号は短く文の頭にあるので、これより後ろの境目は番号の後ろではない。長い文で文頭からの切り出しを繰り返さない。 */
@@ -70,18 +74,34 @@ const followsItemNumber = (text: string, boundary: Boundary, itemNumbers: Readon
 const calendarStarts = (sentence: Sentence, units: CalendarUnits): ReadonlySet<number> =>
   new Set(calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run }) => run.start));
 
+/** 英数字の側が spans のどれか（メールアドレス・URL・番号）の中にある境目。 */
+const besideSpan = (spans: readonly Span[], boundary: Boundary): boolean =>
+  isInsideSpan(spans, boundary.offset - 1) || isInsideSpan(spans, boundary.spaced ? boundary.offset + 1 : boundary.offset);
+
+/** 文の中で一度だけ探すもの: 日付・時刻の数の頭の位置、コロンで書いた時刻、メールアドレス・URL、予約番号や型番のような番号。 */
+type SentenceCodes = {
+  readonly calendar: ReadonlySet<number>;
+  readonly clockTimes: readonly Span[];
+  readonly addresses: readonly Span[];
+  readonly identifiers: readonly Span[];
+};
+
 /**
  * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目、文頭の項目の番号（「一 JIS」）の後ろの境目は、空け方の好みではないので数えない。
- * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。
+ * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。コロンで書いた時刻（13:30）も同じ。
+ * メールアドレス・URL の前後の境目も数えない（spacing-code.ts）。「予約番号 MN-48215 を」の番号の前後も、番号を文から区切る空白なので数えない。
  * 「本社 5階」のように名前の後ろに空白で区切った階・部屋の番号の前の空白も、所在の組の区切りなので数えない（location-part.ts）。
+ * 「経営企画部 IR担当」のように名前だけを並べた行で、名前と名前を分ける空白も数えない（name-separator.ts）。
  */
-const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlySet<number>): boolean => {
-  if (followsItemNumber(sentence.text, boundary, context.itemNumbers)) return false;
+const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, codes: SentenceCodes): boolean => {
+  if (followsItemNumber(sentence.text, boundary, context.itemNumbers) || besideSpan(codes.identifiers, boundary)) return false;
   if (boundary.kind !== "after-digit" && endsWithDivisionLabel(sentence.text.slice(0, boundary.offset), context.divisions)) return false;
-  if (boundary.kind === "letter") return true;
+  if (boundary.kind === "letter")
+    return !besideSpan(codes.addresses, boundary) && !isNameSeparator(sentence.text, boundary, sentence.tokens, sentence.span.start, context.organizations);
+  if (isInsideSpan(codes.clockTimes, digitBeside(boundary))) return false;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
   if (run === undefined) return true;
-  if (calendar.has(run.start)) return false;
+  if (codes.calendar.has(run.start)) return false;
   if (boundary.kind === "before-digit" && isSpacedLocationPart(sentence.text, run, sentence.tokens, sentence.span.start, context.floors)) return false;
   return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context);
 };
@@ -150,13 +170,19 @@ export const latinSpacing: Detector = (doc, options): Finding[] => {
     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") },
+    organizations: { units: patternsOf(doc, "organization-unit"), forms: patternList(doc, "company-form") },
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);
-    const calendar = calendarStarts(sentence, context.calendar);
+    const codes = {
+      calendar: calendarStarts(sentence, context.calendar),
+      clockTimes: clockTimeSpans(sentence.text),
+      addresses: addressSpans(sentence.text),
+      identifiers: identifierSpans(sentence.text),
+    };
     return latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
       .filter((boundary) => !isQuoted(quoted, boundary) && !isInsideLink(doc.links, sentence.span.start + boundary.offset))
-      .filter((boundary) => isCounted(sentence, boundary, context, calendar))
+      .filter((boundary) => isCounted(sentence, boundary, context, codes))
       .map((boundary) => ({ sentence, ...boundary }));
   });
   return KINDS.flatMap((kind) =>

package/src/detectors/period-label-conflict.ts

@@ -0,0 +1,43 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { periodLabelConflicts, type ReportingWords } from "../structure/period-label-conflict.ts";
+import { compileFrames, type Era, type PeriodFrame } from "../structure/period-labels.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const framesOf = (doc: ProseDocument, lexicon: string, titleAlone: boolean): PeriodFrame[] =>
+  (doc.lexicons[lexicon] ?? []).flatMap((entry) =>
+    entry.group === undefined ? [] : [{ pattern: entry.pattern, kind: entry.group, insteadOf: entry.instead_of, titleAlone }],
+  );
+
+const erasOf = (doc: ProseDocument): Era[] =>
+  (doc.lexicons["calendar-era"] ?? []).flatMap((entry) => (entry.first_year === undefined ? [] : [{ name: entry.pattern, firstYear: entry.first_year }]));
+
+/**
+ * 期間の名前の書き方と種類（group）、業績の語、期間の行の語、比べる相手と見込みの語、今の期間の語とそれに似た別の語、名前に似た別の語は語彙表から取る。
+ * reporting-year-frame の書き方（令和8年分、Tax Year 2026）は業績の語の無い題からも読む。元号の年は calendar-era の元年で西暦にする。
+ */
+const wordsOf = (doc: ProseDocument): ReportingWords => ({
+  frames: compileFrames([...framesOf(doc, "reporting-period-frame", false), ...framesOf(doc, "reporting-year-frame", true)], erasOf(doc)),
+  results: patternsOf(doc, "reporting-results-word"),
+  periodLines: patternsOf(doc, "reporting-period-line"),
+  comparisons: patternsOf(doc, "reporting-comparison"),
+  forecasts: patternsOf(doc, "reporting-forecast"),
+  currents: patternsOf(doc, "reporting-current"),
+  notCurrents: patternsOf(doc, "reporting-current-not"),
+  notNames: patternsOf(doc, "reporting-period-not"),
+});
+
+/** 題で言った決算の期間と同じ種類の別の期間を、今の業績を言う所に書いた所。 */
+export const periodLabelConflict: Detector = (doc): Finding[] => {
+  const headings = (doc.markup?.headings ?? []).map((heading) => ({ start: heading.start, end: heading.end, text: heading.text }));
+  const sentences = doc.sentences.map((sentence) => sentence.span);
+  return periodLabelConflicts(doc.source, sentences, headings, wordsOf(doc)).map((issue) => ({
+    rule: "period-label-conflict",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { label: issue.label, stated: issue.stated, offset: issue.offset },
+  }));
+};

package/src/detectors/period-multiple-mismatch.ts

@@ -0,0 +1,54 @@
+// period-multiple-mismatch: an amount stated as a number of another period's amount (月払の12か月分, 12 monthly payments)
+// that is not that many of it (structure/period-multiple.ts). The amounts are currency-notation's, read with
+// amount-multiplier's words of scale; the base labels are period-multiple-label, the words period-multiple-word, the counts
+// number-word (digit), and a range of counts is joined by range-connector or amount-range-word.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { periodMultipleMismatches, type PeriodMultipleWords } from "../structure/period-multiple.ts";
+import type { StatedAmount } from "../structure/stated-multiple.ts";
+import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const numberWordsOf = (doc: ProseDocument): PeriodMultipleWords["numberWords"] =>
+  (doc.lexicons["number-word"] ?? []).flatMap((entry) =>
+    entry.group === "digit" && entry.weight !== undefined ? [{ word: entry.pattern, value: entry.weight }] : [],
+  );
+
+const wordsOf = (doc: ProseDocument): PeriodMultipleWords => ({
+  bases: patternsOf(doc, "period-multiple-label"),
+  times: patternsOf(doc, "period-multiple-word", "times"),
+  links: patternsOf(doc, "period-multiple-word", "link"),
+  skips: patternsOf(doc, "period-multiple-word", "skip"),
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+  numberWords: numberWordsOf(doc),
+});
+
+const amountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
+  const scales = scaleWordsOf(doc);
+  return amountsIn(
+    text,
+    formsOf(doc),
+    scales.map((scale) => scale.word),
+  ).flatMap((amount) => {
+    const read = scaledAmountOf(text, amount, scales);
+    return read === undefined
+      ? []
+      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
+  });
+};
+
+export const periodMultipleMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return periodMultipleMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+    rule: "period-multiple-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/period-part.ts

@@ -0,0 +1,71 @@
+import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+import { hyphenatedCounts } from "../derived/hyphenated-counts.ts";
+import { periodPartIssues, tableRowsOf, type PeriodLength, type PeriodPartWords, type PlacedWord } from "../derived/period-parts.ts";
+import { DURATION_LEXICONS, quantitiesOf } from "./derived-numbers.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const UNITS: readonly DurationUnit[] = ["day", "week", "month", "year"];
+const isDurationUnit = (group: string | undefined): group is DurationUnit => UNITS.some((unit) => unit === group);
+
+/** 期間の単位（か月、months）と、年数にもなる単位（「保証期間は1年」の 年。retention-unit の group が大きさ）。 */
+const unitOf = (doc: ProseDocument, unit: string): DurationUnit | undefined => {
+  const folded = unit.normalize("NFKC").toLowerCase();
+  const listed = DURATION_LEXICONS.find(([id]) => patternsOf(doc, id).some((pattern) => pattern.normalize("NFKC").toLowerCase() === folded))?.[1];
+  const extra = (doc.lexicons["retention-unit"] ?? []).find((entry) => entry.pattern.normalize("NFKC") === folded)?.group;
+  return listed ?? (isDurationUnit(extra) ? extra : undefined);
+};
+
+const datesOf = (tree: StructureNode) => spanIndex(inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [node.span] : [])));
+
+/** 木の数量（12か月、2 years）と名詞の前の期間（a 12-month warranty）。日付の中の数（2026年）は読まない。 */
+const lengthsOf = (doc: ProseDocument, tree: StructureNode): PeriodLength[] => {
+  const dates = datesOf(tree);
+  const hyphenated = hyphenatedCounts(
+    doc.source,
+    DURATION_LEXICONS.flatMap(([id]) => patternsOf(doc, id)),
+  );
+  return [...quantitiesOf(tree, doc.source), ...hyphenated]
+    .flatMap((quantity): PeriodLength[] => {
+      const unit = unitOf(doc, quantity.unit);
+      return unit === undefined || overlapsAny(dates, quantity) ? [] : [{ start: quantity.start, end: quantity.end, amount: quantity.amount, unit }];
+    })
+    .toSorted((left, right) => left.start - right.start);
+};
+
+const placed = (doc: ProseDocument, id: string): PlacedWord[] =>
+  (doc.lexicons[id] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+/** 印、期間の語、後に来る期間の語、長さを言う語、目安と幅の語は語彙表から取る。 */
+const wordsOf = (doc: ProseDocument): PeriodPartWords => ({
+  markers: (doc.lexicons["period-part-marker"] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position ?? "after", group: entry.group })),
+  periodWords: patternsOf(doc, "period-part-word"),
+  afterWords: patternsOf(doc, "period-part-after"),
+  lengthVerbs: patternsOf(doc, "period-part-length-verb"),
+  approximate: placed(doc, "approximate-marker"),
+  rangeJoiners: patternsOf(doc, "period-part-range"),
+  inlineJoiners: patternsOf(doc, "period-part-inline-joiner"),
+  unnamed: patternsOf(doc, "period-part-unnamed"),
+});
+
+const written = (doc: ProseDocument, span: { start: number; end: number }): string => doc.source.slice(span.start, span.end);
+
+/** 期間の一部として書いた期間が、全体の期間より長い（保証期間（12か月）のうち、無料交換期間は18か月）。 */
+export const periodPartExceedsWhole: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const units = [...doc.sentences.map((sentence) => sentence.span), ...tableRowsOf(doc.source)].toSorted((left, right) => left.start - right.start);
+  const sectionStarts = (doc.markup?.headings ?? []).map((heading) => heading.start);
+  const input = { source: doc.source, units, sectionStarts, lengths: lengthsOf(doc, doc.structure), words: wordsOf(doc) };
+  return periodPartIssues(input).map(({ part, whole }) => ({
+    rule: "period-part-exceeds-whole",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, part.start),
+    values: { part: written(doc, part), whole: written(doc, whole), offset: part.start },
+  }));
+};

package/src/detectors/quantity-range.ts

@@ -0,0 +1,47 @@
+// quantity-range-reversed: a range of measured quantities whose upper end is below its lower end (5–2 kg, 30〜10 cm,
+// 40〜-10℃), decided by structure/amount-range.ts as amount-range-reversed is. The quantities are read with the unit
+// lexicons (unit-length, unit-mass, …); the joints are range-connector, range-opener, range-closer and quantity-range-word;
+// quantity-change-word (its lead group: a word right before the range) and quantity-bound-label say what makes a pair a
+// change and what labels a bound.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { measuredValues } from "../facts/measures.ts";
+import { measureUnitsOf } from "../facts/measure-units.ts";
+import { reversedAmountRanges, type AmountRangeWords } from "../structure/amount-range.ts";
+import { quantityRangeEnds, unledRanges } from "../structure/quantity-range.ts";
+import { AMOUNT } from "./currency-notation.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+/** A bare end may carry a minus sign (-10〜-40℃); a hyphen right after a digit or a letter is a range mark (5-10 kg). */
+const SIGNED_NUMBER = `(?:[-−－](?=[0-9０-９]))?${AMOUNT}`;
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const ungroupedOf = (doc: ProseDocument, lexicon: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === undefined).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): AmountRangeWords => ({
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "quantity-range-word")],
+  openers: patternsOf(doc, "range-opener"),
+  closers: patternsOf(doc, "range-closer"),
+  changes: ungroupedOf(doc, "quantity-change-word"),
+  lowers: patternsOf(doc, "quantity-bound-label", "lower"),
+  uppers: patternsOf(doc, "quantity-bound-label", "upper"),
+  links: patternsOf(doc, "quantity-bound-label", "link"),
+  scales: [],
+  number: SIGNED_NUMBER,
+});
+
+export const quantityRange: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const reversed = reversedAmountRanges(text, quantityRangeEnds(text, measuredValues(text, measureUnitsOf(doc))), wordsOf(doc));
+  return unledRanges(text, reversed, patternsOf(doc, "quantity-change-word", "lead")).map((issue) => ({
+    rule: "quantity-range-reversed",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/range-band.ts

@@ -0,0 +1,125 @@
+// range-band-mismatch: neighbouring bands of one table column or one list that overlap or leave a gap (structure/range-bands.ts).
+// The words that bound a band are range-band-word's, the units range-band-unit's, and the column headings that say what bare
+// numbers count range-band-heading's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import {
+  bandSlips,
+  headingOf,
+  parseBand,
+  runKindOf,
+  type BandMarker,
+  type BandSlip,
+  type BandWords,
+  type PlacedBand,
+  type UnitKind,
+} from "../structure/range-bands.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const MARKER_GROUPS: Readonly<Record<string, Pick<BandMarker, "side" | "kind">>> = {
+  "lower-inclusive": { side: "low", kind: "inclusive" },
+  "lower-exclusive": { side: "low", kind: "exclusive" },
+  "upper-inclusive": { side: "high", kind: "inclusive" },
+  "upper-exclusive": { side: "high", kind: "exclusive" },
+};
+
+const isUnitKind = (group: string | undefined): group is UnitKind => group === "integer" || group === "continuous";
+
+export const bandWordsOf = (lexicons: ProseDocument["lexicons"]): BandWords => {
+  const words = lexicons["range-band-word"] ?? [];
+  const patterns = (group: string): string[] => words.filter((entry) => entry.group === group).map((entry) => entry.pattern);
+  return {
+    connectors: patterns("connector"),
+    openers: words.filter((entry) => entry.group === "connector" && entry.position === "before").map((entry) => entry.pattern),
+    leads: patterns("lead"),
+    markers: words.flatMap((entry) => {
+      const marker = MARKER_GROUPS[entry.group ?? ""];
+      return marker === undefined ? [] : [{ pattern: entry.pattern, ...marker, position: entry.position ?? "after" }];
+    }),
+    units: (lexicons["range-band-unit"] ?? []).flatMap((entry) =>
+      isUnitKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group, position: entry.position ?? "after" }] : [],
+    ),
+    headings: (lexicons["range-band-heading"] ?? []).flatMap((entry) => (isUnitKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group }] : [])),
+  };
+};
+
+type Slot = { readonly text: string; readonly start: number; readonly end: number };
+
+/** Runs of consecutive slots that each state a band. A slot that is not one (合計, a blank) ends the run. */
+const bandRuns = (slots: readonly (Slot | undefined)[], words: BandWords): PlacedBand[][] =>
+  slots
+    .reduce<PlacedBand[][]>(
+      (runs, slot) => {
+        const band = slot === undefined ? undefined : parseBand(slot.text, words);
+        if (slot === undefined || band === undefined) return [...runs, []];
+        const last = runs.at(-1) ?? [];
+        return [...runs.slice(0, -1), [...last, { band, start: slot.start, end: slot.end, text: slot.text.trim() }]];
+      },
+      [[]],
+    )
+    .filter((run) => run.length > 1);
+
+const slipsOfRuns = (runs: readonly PlacedBand[][], heading: ReturnType<typeof headingOf>, words: BandWords): BandSlip[] =>
+  runs.flatMap((run) => {
+    const kind = runKindOf(
+      run.map((placed) => placed.band),
+      heading,
+      words,
+    );
+    return kind === undefined ? [] : bandSlips(run, kind);
+  });
+
+const trimmedSlot = (text: string, start: number): Slot => {
+  const lead = text.length - text.trimStart().length;
+  return { text: text.trim(), start: start + lead, end: start + lead + text.trim().length };
+};
+
+const tableSlips = (source: string, words: BandWords): BandSlip[] =>
+  tablesOf(linesOf(source)).flatMap((table) => {
+    const headings = cellsOf(table.header);
+    const rows = table.rows.map(cellsOf);
+    return headings.flatMap((heading, column) =>
+      slipsOfRuns(
+        bandRuns(
+          rows.map((cells) => {
+            const cell = cells[column];
+            return cell === undefined ? undefined : trimmedSlot(cell.text, cell.start);
+          }),
+          words,
+        ),
+        headingOf(heading.text, words),
+        words,
+      ),
+    );
+  });
+
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/u;
+/** Where the band at the head of a list item ends: a colon, a comma, a bracket, or a dash set off by spaces. */
+const ITEM_HEAD_END = /[:：、,，(（]|\s[-–—]\s|\t/u;
+
+const listSlips = (doc: ProseDocument, words: BandWords): BandSlip[] =>
+  doc.lists.flatMap((list) => {
+    const heads = list.itemSpans.map((span): Slot | undefined => {
+      const item = doc.source.slice(span.start, span.end).split("\n")[0] ?? "";
+      const marker = LIST_MARKER.exec(item)?.[0];
+      if (marker === undefined) return undefined;
+      const body = item.slice(marker.length);
+      const end = ITEM_HEAD_END.exec(body)?.index ?? body.length;
+      return trimmedSlot(body.slice(0, end), span.start + marker.length);
+    });
+    return slipsOfRuns(bandRuns(heads, words), undefined, words);
+  });
+
+export const rangeBand: Detector = (doc): Finding[] => {
+  const words = bandWordsOf(doc.lexicons);
+  return [...tableSlips(doc.source, words), ...listSlips(doc, words)].map((slip) => ({
+    rule: "range-band-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.later.start),
+    ...(slip.kind === "gap" ? { variant: "gap" } : {}),
+    values: { earlier: slip.earlier.text, later: slip.later.text, offset: slip.later.start },
+  }));
+};