chaffjs 0.27.1 → 0.29.0

package/src/detectors/connective-hierarchy.ts

@@ -11,8 +11,15 @@ export type LoneConnective = { readonly offset: number; readonly written: string
 
 const CONJUNCTION = "CCONJ";
 
-/** The word lists the detector reads: the connectives, and the phrases that hold one's letters without being one (歯並びに). */
-export type ConnectiveLists = { readonly connectives: readonly LexiconEntry[]; readonly lookalikes: readonly LexiconEntry[] };
+/**
+ * The word lists the detector reads: the connectives, the phrases that hold one's letters without being one (歯並びに), and
+ * the ends of a condition clause (ときは、): an inner-level word is looked for in the outer-level word's own clause only.
+ */
+export type ConnectiveLists = {
+  readonly connectives: readonly LexiconEntry[];
+  readonly lookalikes: readonly LexiconEntry[];
+  readonly clauseEnds: readonly LexiconEntry[];
+};
 
 /**
  * The tagger does not always tell a connective from a noun and a particle: it reads 申請書並びに as 並び + に and
@@ -62,30 +69,51 @@ const standsAsConnective = (reading: Reading, span: Span): boolean => {
   return tagged || joinsNouns(previous, reading.byStart.get(span.end));
 };
 
-const hasInnerLevel = (sentence: Sentence, outer: LexiconEntry, connectives: readonly LexiconEntry[]): boolean =>
-  connectives.some((entry) => entry.instead_of === outer.pattern && sentence.text.includes(entry.pattern));
+/**
+ * The clause of the text the letter at `at` is in: from the end of the last clause end before it (ときは、) to the end of
+ * the first one after it. A list in a condition clause and one in the main clause are not levels of one list. A clause
+ * end with a connective right after it (…ときは、又は…場合には) joins two conditions, and does not cut.
+ */
+export const clauseAround = (text: string, at: number, clauseEnds: readonly LexiconEntry[], connectives: readonly LexiconEntry[] = []): string => {
+  const joinsNext = (end: number): boolean => connectives.some(({ pattern }) => pattern !== "" && text.startsWith(pattern, end));
+  const ends = clauseEnds
+    .filter(({ pattern }) => pattern !== "")
+    .flatMap(({ pattern }) => placesOf(text, pattern).map((start) => start + pattern.length))
+    .filter((end) => !joinsNext(end));
+  const start = Math.max(0, ...ends.filter((end) => end <= at));
+  const end = Math.min(text.length, ...ends.filter((end) => end > at));
+  return text.slice(start, end);
+};
+
+const hasInnerLevel = (clause: string, outer: LexiconEntry, connectives: readonly LexiconEntry[]): boolean =>
+  connectives.some((entry) => entry.instead_of === outer.pattern && clause.includes(entry.pattern));
 
-/** Where one outer-level word stands as a connective in the sentence. */
-const connectiveSpans = (sentence: Sentence, outer: LexiconEntry, reading: Reading): Span[] =>
+/** Where one outer-level word stands as a connective in the sentence with no inner-level word in its clause. */
+const connectiveSpans = (sentence: Sentence, outer: LexiconEntry, reading: Reading, lists: ConnectiveLists): Span[] =>
   placesOf(sentence.text, outer.pattern)
     .filter((at) => reading.hidden[at] !== true)
+    .filter((at) => !hasInnerLevel(clauseAround(sentence.text, at, lists.clauseEnds, lists.connectives), outer, lists.connectives))
     .map((at) => ({ start: sentence.span.start + at, end: sentence.span.start + at + outer.pattern.length }))
     .filter((span) => standsAsConnective(reading, span));
 
 /** The outer-level connectives of a sentence that stand over no inner level. */
 export const loneConnectivesIn = (sentence: Sentence, lists: ConnectiveLists): LoneConnective[] => {
-  const lone = lists.connectives.filter(
-    (entry) => entry.rewrite !== undefined && sentence.text.includes(entry.pattern) && !hasInnerLevel(sentence, entry, lists.connectives),
-  );
+  const lone = lists.connectives.filter((entry) => entry.rewrite !== undefined && sentence.text.includes(entry.pattern));
   if (lone.length === 0) return [];
   const reading = readingOf(sentence, lists.lookalikes);
   return lone
-    .flatMap((entry) => connectiveSpans(sentence, entry, reading).map((span) => ({ offset: span.start, written: entry.pattern, usual: entry.rewrite ?? "" })))
+    .flatMap((entry) =>
+      connectiveSpans(sentence, entry, reading, lists).map((span) => ({ offset: span.start, written: entry.pattern, usual: entry.rewrite ?? "" })),
+    )
     .sort((a, b) => a.offset - b.offset);
 };
 
 export const connectiveHierarchy: Detector = (doc, options): Finding[] => {
-  const lists = { connectives: options.lexicon ?? [], lookalikes: doc.lexicons["connective-lookalike"] ?? [] };
+  const lists = {
+    connectives: options.lexicon ?? [],
+    lookalikes: doc.lexicons["connective-lookalike"] ?? [],
+    clauseEnds: doc.lexicons["connective-clause-end"] ?? [],
+  };
   return doc.sentences.flatMap((sentence) =>
     loneConnectivesIn(sentence, lists).map((lone) => ({
       rule: "",

package/src/detectors/currency-notation.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { formMinority } from "./form-minority.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
 
 // 一つの文書で、同じ通貨の金額を二通りに書いた所（1,000円 と ¥1,000、$20 と 20 dollars）。どちらが正しいかは決めず、少ないほうを指す。
@@ -14,7 +15,7 @@ export type WrittenAmount = { readonly offset: number; readonly written: string;
 /** 少ないほうの書き方の金額と、多いほうの書き方の例、その通貨の金額の数。 */
 export type CurrencyMinority = { readonly odd: WrittenAmount; readonly usual: string; readonly count: number; readonly of: number };
 
-const AMOUNT = "[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?";
+export const AMOUNT = "[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?";
 
 const alternation = (words: readonly string[]): string => words.map(escapeRegExp).join("|");
 
@@ -71,13 +72,13 @@ export const currencyMinorities = (amounts: readonly WrittenAmount[], limit: num
     )
     .toSorted((left, right) => left.odd.offset - right.odd.offset);
 
-const formsOf = (doc: ProseDocument): CurrencyForm[] =>
+export const formsOf = (doc: ProseDocument): CurrencyForm[] =>
   (doc.lexicons["currency-notation"] ?? []).flatMap((entry) =>
     entry.position === undefined || entry.group === undefined ? [] : [{ pattern: entry.pattern, position: entry.position, currency: entry.group }],
   );
 
 export const currencyNotation: Detector = (doc, options): Finding[] => {
-  const text = doc.prose ?? doc.source;
+  const text = proseAndTablesOf(doc);
   const multipliers = (doc.lexicons["amount-multiplier"] ?? []).map((entry) => entry.pattern);
   return currencyMinorities(amountsIn(text, formsOf(doc), multipliers), options.limit).map(({ odd, usual, count, of }) => ({
     rule: "",

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

@@ -0,0 +1,38 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { datesOutsidePeriod, type OutsideWords } from "../structure/date-outside-period.ts";
+import { rangeFrameOf } from "../structure/date-range.ts";
+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 の間の語）、月と曜日の名は語彙表から取る。 */
+const wordsOf = (doc: ProseDocument): OutsideWords => ({
+  labels: patternsOf(doc, "period-label"),
+  asides: patternsOf(doc, "period-aside"),
+  connectors: [
+    ...patternsOf(doc, "range-connector"),
+    ...patternsOf(doc, "range-opener"),
+    ...patternsOf(doc, "range-frame").flatMap((pattern) => rangeFrameOf(pattern)?.joint ?? []),
+  ],
+  months: patternsOf(doc, "month-name"),
+  weekdays: patternsOf(doc, "weekday"),
+});
+
+/** 書いた期間（旅行期間：…）の外の日付を持つ、その後ろの日程の項目、表の行、見出し。 */
+export const dateOutsidePeriod: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const dates = inDocumentOrder(doc.structure).flatMap((node) =>
+    node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : [],
+  );
+  const headings = doc.markup?.headings ?? [];
+  const sentences = doc.sentences.map((sentence) => sentence.span);
+  return datesOutsidePeriod(doc.source, dates, headings, sentences, wordsOf(doc)).map((issue) => ({
+    rule: "date-outside-period",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/default-values.ts

@@ -0,0 +1,17 @@
+// default-value-mismatch: one parameter's default stated two ways on a page (default-values.ts). The header words of a
+// default column and the phrases that state a default in prose come from the default-header and default-phrase lexicons.
+import { quoteAt } from "./structure-tree.ts";
+import { defaultSlips } from "../default-values.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const lowercase = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern.toLowerCase());
+
+export const defaultValues: Detector = (doc): Finding[] =>
+  defaultSlips(doc.source, { headers: lowercase(doc, "default-header"), phrases: lowercase(doc, "default-phrase") }).map((slip) => ({
+    rule: "default-value-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.offset),
+    values: { name: slip.name, value: slip.value, expected: slip.expected, offset: slip.offset },
+  }));

package/src/detectors/defined-term-form.ts

@@ -5,6 +5,8 @@ import { definedTerms, usesOf, type BodyText, type DefinedTerm } from "../struct
 import { escapeRegExp } from "../orthography.ts";
 import { prefixGroupsOf, prefixVariants, variantUses } from "../structure/term-prefix.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { isPartOfAddress } from "./address-word.ts";
+import { exactOffsets, extendedAfter, extendedBefore } from "./term-extension.ts";
 import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
 const bodyOf = (doc: ProseDocument): BodyText[] => doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
@@ -50,17 +52,32 @@ export const quotedUses = (source: string, term: string, uses: readonly number[]
   });
 
 const UPPER_START = /^\p{Lu}/u;
+/** The capital that starts each later word of a term (the O of Records Officer). */
+const INNER_CAPITAL = /(?<=\s)\p{Lu}/gu;
+
+const innerCapitals = (term: string): number[] => [...term.matchAll(INNER_CAPITAL)].map((match) => match.index);
+
+/** Whether the letter at position at of the term is written in lower case at this use. */
+const isLowered = (source: string, term: string, offset: number, at: number): boolean => source.charAt(offset + at) === term.charAt(at).toLowerCase();
+
+/** The term with the capitals of its later words in lower case (Records officer), whose uses the term's own form does not find. */
+export const innerLowered = (term: string): string => term.replace(INNER_CAPITAL, (capital) => capital.toLowerCase());
 
 /**
- * The uses of a capitalised term written in lower case ("services" where "Services" is defined), when they are the fewer
- * and at most limit: a document that mostly writes it in lower case uses the word in its ordinary sense on purpose.
+ * The uses of a capitalised term written in lower case ("services" where "Services" is defined, "records officer" where
+ * "Records Officer" is), when they are no more than the capitalised uses and at most limit: a document that writes it in
+ * lower case more often uses the word in its ordinary sense on purpose. One of each is a slip to point at (the Software,
+ * then the software).
  */
 export const lowerCaseUses = (source: string, term: string, uses: readonly number[], definedAt: number, limit: number): number[] => {
   if (!UPPER_START.test(term) || term.toLowerCase() === term) return [];
-  const later = uses.filter((offset) => offset > definedAt);
-  const lower = later.filter((offset) => source.charAt(offset) === term.charAt(0).toLowerCase() && !isSentenceStart(source, offset));
-  const capital = later.filter((offset) => source.charAt(offset) === term.charAt(0));
-  return lower.length > 0 && lower.length < capital.length && lower.length <= limit ? lower : [];
+  const inner = innerCapitals(term);
+  // An address (support@pinecone.example) spells the name as the address must be, in either case; it is not a use.
+  const later = uses.filter((offset) => offset > definedAt && !isPartOfAddress(source, offset, offset + term.length));
+  const innerLower = (offset: number): boolean => inner.some((at) => isLowered(source, term, offset, at));
+  const lower = later.filter((offset) => (isLowered(source, term, offset, 0) && !isSentenceStart(source, offset)) || innerLower(offset));
+  const capital = later.filter((offset) => source.charAt(offset) === term.charAt(0) && !innerLower(offset));
+  return lower.length > 0 && lower.length <= capital.length && lower.length <= limit ? lower : [];
 };
 
 /** How far back a sentence's start is looked for: past a few spaces to the mark before them. */
@@ -74,16 +91,22 @@ const isSentenceStart = (source: string, offset: number): boolean => {
   return (offset < LOOK_BACK && text === "") || before.slice(text.length).includes("\n") || SENTENCE_END.has(text.at(-1) ?? "");
 };
 
+const definingSentence = (doc: ProseDocument, definition: Span): Sentence | undefined =>
+  doc.sentences.find((sentence) => sentence.span.start <= definition.start && definition.start < sentence.span.end);
+
 /** Where the sentence holding the definition ends: a use inside it ("Customer" means the party named "Customer") belongs to the definition. */
-const definingSentenceEnd = (doc: ProseDocument, definition: Span): number =>
-  doc.sentences.find((sentence) => sentence.span.start <= definition.start && definition.start < sentence.span.end)?.span.end ?? definition.end;
+const definingSentenceEnd = (doc: ProseDocument, definition: Span): number => definingSentence(doc, definition)?.span.end ?? definition.end;
 
 const VERBAL = new Set(["VERB", "AUX"]);
 
+const tokensAt = (doc: ProseDocument, offset: number): { readonly tokens: readonly Token[]; readonly at: number } => {
+  const tokens = doc.sentences.find((candidate) => candidate.span.start <= offset && offset < candidate.span.end)?.tokens ?? [];
+  return { tokens, at: tokens.findIndex((candidate) => candidate.span.start <= offset && offset < candidate.span.end) };
+};
+
 /** A word used as a verb ("you input"), not the defined thing ("the Input"): a different word that shares the spelling. */
 const isVerbAt = (doc: ProseDocument, offset: number): boolean => {
-  const tokens = doc.sentences.find((candidate) => candidate.span.start <= offset && offset < candidate.span.end)?.tokens ?? [];
-  const at = tokens.findIndex((candidate) => candidate.span.start <= offset && offset < candidate.span.end);
+  const { tokens, at } = tokensAt(doc, offset);
   const token = tokens[at];
   if (token === undefined) return false;
   // After a subject pronoun the word is its verb (you input), whatever the tagger says; after a possessive (your input) it is a noun.
@@ -92,6 +115,26 @@ const isVerbAt = (doc: ProseDocument, offset: number): boolean => {
   return VERBAL.has(token.pos) || afterSubject;
 };
 
+const NAMING = new Set(["NOUN", "PROPN"]);
+
+/**
+ * A lower-case phrase that starts with a noun and has no adjective before it (the records officer) names the defined thing.
+ * One that starts with an adjective or a possessive (its own confidential information, your content), or that an
+ * adjective narrows (additional terms of service), is the ordinary phrase.
+ */
+const isNamingAt = (doc: ProseDocument, offset: number): boolean => {
+  const { tokens, at } = tokensAt(doc, offset);
+  return NAMING.has(tokens[at]?.pos ?? "") && tokens[at - 1]?.pos !== "ADJ";
+};
+
+/** The uses of the term, with those that write its later words in lower case (records officer for Records Officer), in order. */
+const withLoweredWords = (doc: ProseDocument, term: string, texts: readonly BodyText[], spans: readonly Span[], uses: readonly number[]): number[] => {
+  const lowered = innerLowered(term);
+  if (lowered === term) return [...uses];
+  const more = usesOf(lowered, texts, spans, "loose").filter((offset) => !uses.includes(offset) && isNamingAt(doc, offset));
+  return [...uses, ...more].toSorted((left, right) => left - right);
+};
+
 /** The term written with another prefix of its group (本件業務 where 本業務 is defined), after the sentence that defines it. */
 const prefixFindings = (doc: ProseDocument, texts: readonly BodyText[], term: DefinedTerm, definingEnd: number, defined: readonly string[]): Finding[] =>
   prefixVariants(term.term, prefixGroupsOf(doc.lexicons["defined-term-prefix"] ?? [])).flatMap((variant) =>
@@ -102,6 +145,33 @@ const prefixFindings = (doc: ProseDocument, texts: readonly BodyText[], term: De
         ),
   );
 
+/** The term set in quotes again, unless the document's profile says a quoted term is the term mentioned (「株主」とあるのは). */
+const quotedFindings = (doc: ProseDocument, term: DefinedTerm, uses: readonly number[], definingEnd: number): Finding[] =>
+  doc.profile?.quoteMentionsTerm === true
+    ? []
+    : quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
+        finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }),
+      );
+
+/** The term written longer with a word of its definition (文書管理責任者, the Application), after the sentence that defines it. */
+const extendedFindings = (doc: ProseDocument, texts: readonly BodyText[], term: DefinedTerm, spans: readonly Span[], defined: readonly string[]): Finding[] => {
+  const definition = definingSentence(doc, term.span)?.text ?? "";
+  const pointers = (doc.lexicons["defined-term-pointer"] ?? []).map((entry) => entry.pattern);
+  // Every sentence that defines the term (a second definition too) holds the long words it is defined from.
+  const defining = spans.map((span) => definingSentence(doc, span)?.span ?? span);
+  const definingEnd = definingSentenceEnd(doc, term.span);
+  return texts
+    .flatMap((text) => exactOffsets(text.text, text.start, term.term))
+    .filter((offset) => offset > definingEnd && !defining.some((span) => span.start <= offset && offset < span.end))
+    .flatMap((offset) => {
+      const before = extendedBefore(doc.source, offset, term.term, definition, pointers);
+      const written = before ?? (isSentenceStart(doc.source, offset) ? undefined : extendedAfter(doc.source, offset, term.term, definition));
+      if (written === undefined || defined.includes(written)) return [];
+      const start = before === undefined ? offset : offset + term.term.length - written.length;
+      return [finding(doc, "defined-term-form", start, "extended", { term: term.term, written, line: term.line })];
+    });
+};
+
 export const definedTermForm: Detector = (doc, options): Finding[] => {
   if (doc.structure === undefined) return [];
   const texts = bodyOf(doc);
@@ -110,14 +180,13 @@ export const definedTermForm: Detector = (doc, options): Finding[] => {
   return firstDefinitions(terms).flatMap(({ term, spans }) => {
     const uses = usesOf(term.term, texts, spans, "loose");
     const definingEnd = definingSentenceEnd(doc, term.span);
-    const quoted = quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
-      finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }),
-    );
-    const nounUses = uses.filter((offset) => !isVerbAt(doc, offset));
+    const quoted = quotedFindings(doc, term, uses, definingEnd);
+    const caseUses = withLoweredWords(doc, term.term, texts, spans, uses);
+    const nounUses = caseUses.filter((offset) => !isVerbAt(doc, offset));
     const lower = lowerCaseUses(doc.source, term.term, nounUses, definingEnd, options.limit).map((offset) =>
       finding(doc, "defined-term-form", offset, "case", { term: term.term, line: term.line }),
     );
-    return [...quoted, ...lower, ...prefixFindings(doc, texts, term, definingEnd, defined)];
+    return [...quoted, ...lower, ...prefixFindings(doc, texts, term, definingEnd, defined), ...extendedFindings(doc, texts, term, spans, defined)];
   });
 };
 

package/src/detectors/definition-use.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type Mentioned } from "../structure/definition-use.ts";
+import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type IsTitle, type Mentioned } from "../structure/definition-use.ts";
+import { titleLineNumbers } from "../structure/title-lines.ts";
 import { expansionConflicts, expansionsIn } from "../acronym-expansions.ts";
 import { linesOf, lineNumberAt } from "../structure/lines.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
@@ -29,11 +30,18 @@ export const unusedDefinition: Detector = (doc): Finding[] =>
         findingAt(doc, defined.span.start, { term: defined.term }),
       );
 
+/** 題・見出し（Markdown の見出し、章・節の行、条の前の見出しの行）の上の位置か。 */
+const titleIn = (doc: ProseDocument): IsTitle => {
+  const lines = linesOf(doc.source);
+  const numbers = titleLineNumbers(doc.structure, lines, doc.markup?.headings ?? []);
+  return (offset) => numbers.has(lineNumberAt(lines, offset) ?? 0);
+};
+
 /** 文の途中で括弧に入れて定義した語を、定義より前で使っている所。 */
 export const useBeforeDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc)).map((use) =>
+    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc), titleIn(doc)).map((use) =>
         findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }),
       );
 

package/src/detectors/deprecated-use.ts

@@ -0,0 +1,17 @@
+// deprecated-option-used: a name the document calls deprecated, still used in one of its code examples
+// (deprecated-use.ts). The words come from the deprecation-word and deprecation-negated lexicons.
+import { quoteAt } from "./structure-tree.ts";
+import { deprecatedUses } from "../deprecated-use.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const lowercase = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern.toLowerCase());
+
+export const deprecatedUse: Detector = (doc): Finding[] =>
+  deprecatedUses(doc.source, { words: lowercase(doc, "deprecation-word"), negated: lowercase(doc, "deprecation-negated") }).map((use) => ({
+    rule: "deprecated-option-used",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, use.offset),
+    values: { name: use.name, offset: use.offset },
+  }));

package/src/detectors/derived-numbers.ts

@@ -5,6 +5,18 @@ import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import { yearOf, type DurationUnit } from "../derived/date-arithmetic.ts";
 import { durationMismatches, type DatedValue, type Duration } from "../derived/durations.ts";
 import { elapsedMismatches, type Elapsed, type OriginWord, type Year } from "../derived/elapsed.ts";
+import { numberWordCounts } from "../derived/number-word-counts.ts";
+import {
+  nightsDaysMismatches,
+  nightsDaysPairs,
+  stayNightsMismatches,
+  tableNightsMismatches,
+  type Count,
+  type NightsMismatch,
+  type StayColumnWords,
+} from "../derived/stays.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 /** 期間の単位の語彙表。木の数量の単位がどれかに入れば、その単位の期間。 */
@@ -28,11 +40,28 @@ const endWithUnit = (source: string, end: number, unit: string): number => {
   return unit !== "" && source.startsWith(unit, end + gap) ? end + gap + unit.length : end;
 };
 
+const OPEN_BRACKET = " (";
+const WORD_LETTER = /[\p{L}-]/u;
+
+/** Where the word before " (" starts ("six (" in "six (6) months"), or undefined when no word stands there. */
+const wordStartBeforeBracket = (source: string, at: number): number | undefined => {
+  if (source.slice(Math.max(0, at - OPEN_BRACKET.length), at) !== OPEN_BRACKET) return undefined;
+  let start = at - OPEN_BRACKET.length;
+  while (start > 0 && WORD_LETTER.test(source.charAt(start - 1))) start -= 1;
+  return start < at - OPEN_BRACKET.length ? start : undefined;
+};
+
+/** 「six (6) months」は語の数から単位まで。括弧の中の数だけでは、指摘に引いたとき何の期間か読めない。 */
+const withWordsAround = (source: string, start: number, end: number, unit: string): Span => {
+  const wordStart = source.charAt(end) === ")" ? wordStartBeforeBracket(source, start) : undefined;
+  return wordStart === undefined ? { start, end: endWithUnit(source, end, unit) } : { start: wordStart, end: endWithUnit(source, end + 1, unit) };
+};
+
 const quantitiesOf = (tree: StructureNode, source: string): Quantity[] =>
   inDocumentOrder(tree).flatMap((node): Quantity[] => {
     if (node.kind !== "quantity") return [];
     const unit = String(node.attrs["unit"] ?? "");
-    return [{ start: node.span.start, end: endWithUnit(source, node.span.end, unit), amount: Number(node.attrs["value"]), unit: unit.normalize("NFKC") }];
+    return [{ ...withWordsAround(source, node.span.start, node.span.end, unit), amount: Number(node.attrs["value"]), unit: unit.normalize("NFKC") }];
   });
 
 const datesOf = (tree: StructureNode): DatedValue[] =>
@@ -64,24 +93,87 @@ 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);
+  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);
+};
+
+const finding = (doc: ProseDocument, offset: number, values: Record<string, string | number>, variant?: string): Finding => ({
+  rule: "duration-mismatch",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, offset),
+  ...(variant === undefined ? {} : { variant }),
+  values: { ...values, offset },
+});
+
+const written = (doc: ProseDocument, span: Span): string => doc.source.slice(span.start, span.end);
+
+const nightsFinding = (doc: ProseDocument, mismatch: NightsMismatch): Finding =>
+  finding(
+    doc,
+    mismatch.nights.start,
+    { start: written(doc, mismatch.start), end: written(doc, mismatch.end), nights: written(doc, mismatch.nights).trim(), expected: mismatch.expected },
+    "nights",
+  );
+
+const stayColumnWords = (doc: ProseDocument): StayColumnWords => ({
+  checkIn: patternsOf(doc, "stay-check-in-column"),
+  checkOut: patternsOf(doc, "stay-check-out-column"),
+  nights: patternsOf(doc, "stay-nights-column"),
+  units: patternsOf(doc, "stay-night"),
+});
+
+/** 始まり + 期間 ≠ 終わり。泊数が二つの日付の差と合わない。「2泊3日」の日数が泊数より一つ多くない。 */
 export const durationMismatch: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
+  const dates = datesOf(doc.structure);
   const durations = durationsOf(doc, quantitiesOf(doc.structure, doc.source));
-  return durationMismatches(sentencesOf(doc), datesOf(doc.structure), durations).map((mismatch) => ({
-    rule: "duration-mismatch",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAt(doc.source, mismatch.end.start),
-    values: {
-      start: doc.source.slice(mismatch.start.start, mismatch.start.end),
-      duration: doc.source.slice(mismatch.duration.start, mismatch.duration.end),
-      end: doc.source.slice(mismatch.end.start, mismatch.end.end),
+  const proseAndTables = proseAndTablesOf(doc);
+  const nights = nightsOf(doc, proseAndTables);
+  const pairs = nightsDaysPairs(
+    doc.source,
+    nights,
+    durations.filter((duration) => duration.unit === "day"),
+    patternsOf(doc, "stay-pair-joiner"),
+  );
+  const pairedDays = spanIndex(pairs.map((pair) => pair.days));
+  const lengths = durationMismatches(
+    sentencesOf(doc),
+    dates,
+    durations.filter((duration) => !overlapsAny(pairedDays, duration)),
+  ).map((mismatch) =>
+    finding(doc, mismatch.end.start, {
+      start: written(doc, mismatch.start),
+      duration: written(doc, mismatch.duration),
+      end: written(doc, mismatch.end),
       expected: mismatch.expected,
-      offset: mismatch.end.start,
-    },
-  }));
+    }),
+  );
+  const stays = [...stayNightsMismatches(sentencesOf(doc), dates, nights), ...tableNightsMismatches(proseAndTables, dates, stayColumnWords(doc))];
+  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];
 };
 
 /** 四桁の年。木が日付と読まなかった英語の年（founded in 2015、born 1980）もここで読む。 */
@@ -122,8 +214,14 @@ const isAge = (doc: ProseDocument, quantity: Quantity): boolean =>
   positioned(doc, "age-marker", "before").some((word) => textBefore(doc, quantity).endsWith(word)) ||
   positioned(doc, "age-marker", "after").some((word) => textAfter(doc, quantity).startsWith(word));
 
-const elapsedOf = (doc: ProseDocument, quantities: readonly Quantity[]): Elapsed[] =>
-  quantities.filter((quantity) => !isAge(doc, quantity) && patternsOf(doc, "elapsed-unit").some((unit) => unit.normalize("NFKC") === quantity.unit));
+/** 年数: 単位が年数の語の数量（10 years、創業10年）と、木が読まない語で書いた数（ten years）。 */
+const elapsedOf = (doc: ProseDocument, quantities: readonly Quantity[]): Elapsed[] => {
+  const units = patternsOf(doc, "elapsed-unit");
+  const counted = quantities.filter((quantity) => !isAge(doc, quantity) && units.some((unit) => unit.normalize("NFKC") === quantity.unit));
+  const taken = spanIndex(quantities);
+  const worded = numberWordCounts(doc.source, patternsOf(doc, "count-number"), units).filter((count) => !overlapsAny(taken, count));
+  return [...counted, ...worded].toSorted((left, right) => left.start - right.start);
+};
 
 /** 「aged 45」の 45: 英語の木は単位の無い数を読まないので、年齢の印のすぐ後ろの数を読む。 */
 const AGE_NUMBER = /^\s*(\d{1,3})(?!\d)/u;

package/src/detectors/document-shape.ts

@@ -86,6 +86,11 @@ const SENTENCES_INSIDE = /[。．！？](?=\s*\S)|\p{Ll}{2}[.!?]["'”’)]?\s+[
 
 export const isParagraphHeading = (heading: string): boolean => SENTENCES_INSIDE.test(heading.trim());
 
+/** A heading that asks a question: its length is the reader's question, not a name to shorten (FAQ, "Will this … increase …?"). */
+const QUESTION_END = /[?？]["'”’)）」』]*$/u;
+
+export const isQuestionHeading = (heading: string): boolean => QUESTION_END.test(heading.trim());
+
 /** The heading's words without a number label at its head (Chapter 2, 1.), from the section the heading opens. */
 const unlabeledOf = (doc: ProseDocument, heading: MarkupHeading): string =>
   doc.sections.find((section) => section.span.start === heading.end)?.unlabeledHeading ?? heading.text;
@@ -96,7 +101,7 @@ export const titleLength: Detector = (doc, options): Finding[] => {
   const title = headings.find((heading) => heading.depth === 1);
   return headings
     .map((heading) => ({ heading, words: unlabeledOf(doc, heading) }))
-    .filter(({ words }) => !isParagraphHeading(words))
+    .filter(({ words }) => !isParagraphHeading(words) && !isQuestionHeading(words))
     .map(({ heading, words }) => ({ heading, count: headingLength(words, doc.lengthUnit) }))
     .filter(({ count }) => count > options.limit)
     .map(({ heading, count }) => ({

package/src/detectors/due-date.ts

@@ -0,0 +1,47 @@
+// due-before-issue: the reading half. The issue-date and due-date words come from the language's lexicons
+// (issue-date-label, due-date-label, deadline-passed-word), and so do the words of minutes (minutes-title-word, meeting-date-label,
+// action-section-heading, earlier-section-word, action-due-label, item-done-word); the dates are the structure tree's, and the
+// lines are read with code masked.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { actionDueBeforeMeeting, type ActionWords } from "../structure/action-due.ts";
+import { dueBeforeIssue, type DueWords } from "../structure/due-date.ts";
+import type { StructureIssue } from "../structure/issues.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { datedPoints, quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): DueWords => ({
+  issue: patternsOf(doc, "issue-date-label"),
+  due: patternsOf(doc, "due-date-label"),
+  passed: patternsOf(doc, "deadline-passed-word"),
+});
+
+const actionWordsOf = (doc: ProseDocument): ActionWords => ({
+  meeting: patternsOf(doc, "meeting-date-label"),
+  section: patternsOf(doc, "action-section-heading"),
+  earlier: patternsOf(doc, "earlier-section-word"),
+  due: patternsOf(doc, "action-due-label"),
+  done: patternsOf(doc, "item-done-word"),
+  minutes: patternsOf(doc, "minutes-title-word"),
+});
+
+const findingOf = (doc: ProseDocument, issue: StructureIssue, variant?: string): Finding => ({
+  rule: "due-before-issue",
+  severity: "error",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, issue.offset),
+  values: { ...issue.values, offset: issue.offset },
+  ...(variant === undefined ? {} : { variant }),
+});
+
+export const dueDate: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const text = proseAndTablesOf(doc);
+  const dates = datedPoints(doc.structure);
+  return [
+    ...dueBeforeIssue(text, dates, wordsOf(doc)).map((issue) => findingOf(doc, issue)),
+    ...actionDueBeforeMeeting(text, dates, doc.markup?.headings ?? [], actionWordsOf(doc)).map((issue) => findingOf(doc, issue, "meeting")),
+  ];
+};