chaffjs 0.28.0 → 0.29.0

package/src/detectors/amount-scale.ts

@@ -1,15 +1,19 @@
 // amount-scale-consistency: the reading half. The amounts are currency-notation's (the lexicon currency-notation says
 // how a currency is written); the words of scale and their values are the lexicon amount-multiplier (weight).
-import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
 import { escapeRegExp } from "../orthography.ts";
-import { amountValue, scaleMixes, type ScaleWord, type ScaledAmount } from "../structure/amount-scale.ts";
+import { amountValue, scaleMixes, withoutRoundTextFigures, type ScaleWord, type ScaledAmount } from "../structure/amount-scale.ts";
 import { AMOUNT, amountsIn, formsOf, type WrittenAmount } from "./currency-notation.ts";
 import { quoteAround } from "./quote-around.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 
 /** How far back a larger part of one amount may start (1億2,000万円 is read from 2,000万円). */
 const LEADING_REACH = 40;
 
-const scaleWordsOf = (doc: ProseDocument): ScaleWord[] =>
+/** How far from an amount a marker of an estimate is looked for. */
+const MARKER_REACH = 12;
+
+export const scaleWordsOf = (doc: ProseDocument): ScaleWord[] =>
   (doc.lexicons["amount-multiplier"] ?? []).flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }]));
 
 /** The larger parts written right before an amount the currency notation read from its last part (1億 before 2,000万円). */
@@ -34,25 +38,54 @@ const unitOf = (number: string, words: readonly ScaleWord[]): number | undefined
   return values.length === 0 ? undefined : Math.max(...values);
 };
 
+/** One written amount read as a value, with the larger parts written before it (1億 before 2,000万円). */
+export const scaledAmountOf = (text: string, amount: WrittenAmount, words: readonly ScaleWord[]): ScaledAmount | undefined => {
+  const leading = amount.form.startsWith("after:") ? leadingParts(text, amount.offset, words) : "";
+  const written = `${leading}${amount.written}`;
+  const number = `${leading}${numberPart(amount)}`;
+  const value = amountValue(number, words);
+  if (value === undefined) return undefined;
+  return { offset: amount.offset - leading.length, written, currency: amount.currency, value, unit: unitOf(number, words) };
+};
+
 const scaledAmountsOf = (text: string, amounts: readonly WrittenAmount[], words: readonly ScaleWord[]): ScaledAmount[] =>
-  amounts.flatMap((amount) => {
-    const leading = amount.form.startsWith("after:") ? leadingParts(text, amount.offset, words) : "";
-    const written = `${leading}${amount.written}`;
-    const number = `${leading}${numberPart(amount)}`;
-    const value = amountValue(number, words);
-    if (value === undefined) return [];
-    return [{ offset: amount.offset - leading.length, written, currency: amount.currency, value, unit: unitOf(number, words) }];
-  });
+  amounts.flatMap((amount) => scaledAmountOf(text, amount, words) ?? []);
+
+/** Whether a marker of an estimate (約, 程度, about) stands right before or after the amount. */
+const isApproximate = (text: string, amount: ScaledAmount, markers: Lexicon): boolean => {
+  const before = text
+    .slice(Math.max(0, amount.offset - MARKER_REACH), amount.offset)
+    .trimEnd()
+    .toLowerCase();
+  const after = text
+    .slice(amount.offset + amount.written.length, amount.offset + amount.written.length + MARKER_REACH)
+    .trimStart()
+    .toLowerCase();
+  return markers.some((entry) => (entry.position === "after" ? after.startsWith(entry.pattern.toLowerCase()) : before.endsWith(entry.pattern.toLowerCase())));
+};
+
+/** Whether the amount is on a table row (the text has the tables read back in, and only tables start a line with |). */
+const onTableRow = (text: string, amount: ScaledAmount): boolean =>
+  text
+    .slice(text.lastIndexOf("\n", amount.offset) + 1)
+    .trimStart()
+    .startsWith("|");
 
 export const amountScale: Detector = (doc): Finding[] => {
-  const text = doc.prose ?? doc.source;
+  const text = proseAndTablesOf(doc);
   const words = scaleWordsOf(doc);
-  const amounts = amountsIn(
+  const markers = doc.lexicons["approximate-marker"] ?? [];
+  const amounts = scaledAmountsOf(
     text,
-    formsOf(doc),
-    words.map((word) => word.word),
-  );
-  return scaleMixes(scaledAmountsOf(text, amounts, words)).map(({ odd, usual }) => ({
+    amountsIn(
+      text,
+      formsOf(doc),
+      words.map((word) => word.word),
+    ),
+    words,
+  ).filter((amount) => !isApproximate(text, amount, markers));
+  const mixes = withoutRoundTextFigures(scaleMixes(amounts), amounts, (amount) => onTableRow(text, amount));
+  return mixes.map(({ odd, usual }) => ({
     rule: "amount-scale-consistency",
     severity: "info",
     line: 0,

package/src/detectors/announced-count.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { announcedCountMismatches, type CountWords } from "../announced-count.ts";
+import { announcedCountMismatches, type CountMismatch, type CountWords } from "../announced-count.ts";
+import { inlineCountMismatches, type MemberWords } from "../inline-count.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 const patternsOf = (doc: ProseDocument, id: string, position?: "before" | "after"): string[] =>
@@ -13,13 +14,30 @@ const countWordsOf = (doc: ProseDocument): CountWords => ({
   hedgesAfter: patternsOf(doc, "count-hedge", "after"),
 });
 
-/** 予告の数（以下の3点）と、すぐ下の箇条書きの項目の数が違う。 */
-export const announcedCount: Detector = (doc): Finding[] =>
-  announcedCountMismatches(doc.source, doc.lists, countWordsOf(doc)).map((mismatch) => ({
-    rule: "announced-count-mismatch",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAt(doc.source, mismatch.offset),
-    values: { phrase: mismatch.phrase, announced: mismatch.announced, listed: mismatch.listed, offset: mismatch.offset },
-  }));
+const memberGroup = (doc: ProseDocument, group: string): string[] =>
+  (doc.lexicons["count-member"] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const memberWordsOf = (doc: ProseDocument): MemberWords => ({
+  separators: memberGroup(doc, "separator"),
+  joiners: memberGroup(doc, "joiner"),
+  open: memberGroup(doc, "open"),
+});
+
+const findingOf = (doc: ProseDocument, mismatch: CountMismatch, variant?: string): Finding => ({
+  rule: "announced-count-mismatch",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, mismatch.offset),
+  values: { phrase: mismatch.phrase, announced: mismatch.announced, listed: mismatch.listed, offset: mismatch.offset },
+  ...(variant === undefined ? {} : { variant }),
+});
+
+/** 予告の数（以下の3点、出席者（6名））と、すぐ下の箇条書きか、後ろに一行で並べた名前の数が違う。 */
+export const announcedCount: Detector = (doc): Finding[] => {
+  const words = countWordsOf(doc);
+  return [
+    ...announcedCountMismatches(doc.source, doc.lists, words).map((mismatch) => findingOf(doc, mismatch)),
+    ...inlineCountMismatches(doc.prose ?? doc.source, words, memberWordsOf(doc)).map((mismatch) => findingOf(doc, mismatch, "inline")),
+  ];
+};

package/src/detectors/bare-comparative.ts

@@ -1,5 +1,6 @@
-import type { Detector, Finding, Lexicon, Sentence, Span, Token } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { quotedIn } from "../quoted-span.ts";
+import { followsInlineCode } from "./code-before.ts";
 
 /**
  * 比べる相手の無い比較（より良い結果、さらに高速に、The new engine is faster.）。何より良いのか、何より速いのかが書かれていない。
@@ -132,6 +133,10 @@ export const listsOf = (lexicon: Lexicon): ComparativeLists => ({
 /** 鉤括弧の中の比較（「給与所得の確定申告がさらに簡単に！」ページ）は題や語を挙げたもので、書き手の比較ではない。 */
 const insideSpan = (found: BareComparative, span: Span): boolean => found.first.span.start >= span.start && found.last.span.end <= span.end;
 
+/** より right after inline code (`relaxed` より長い) is the particle "than" after a word the masking hid, not the adverb. */
+const isThanAfterCode = (doc: ProseDocument, found: BareComparative): boolean =>
+  found.first.surface === "より" && followsInlineCode(doc.source, doc.prose, found.first.span.start);
+
 export const bareComparative: Detector = (doc): Finding[] => {
   const lists = listsOf(doc.lexicons["comparative-baseline"] ?? []);
   return doc.sentences.flatMap((sentence, at) => {
@@ -139,7 +144,7 @@ export const bareComparative: Detector = (doc): Finding[] => {
     if (sentence.embeddedLanguage !== undefined || nearby.some((near) => namesBaseline(near, lists.baselines))) return [];
     const quoted = quotedIn(sentence);
     return bareComparativesIn(sentence.tokens ?? [], lists)
-      .filter((found) => !quoted.some((span) => insideSpan(found, span)))
+      .filter((found) => !quoted.some((span) => insideSpan(found, span)) && !isThanAfterCode(doc, found))
       .map((found) => ({
         rule: "",
         severity: "info",

package/src/detectors/block-quotation.ts

@@ -0,0 +1,95 @@
+// A block quotation (`> …`) that a dash line gives to someone: `— Name` as the last line of its last paragraph, or as
+// the paragraph right after it. A block quotation with no such line is not given to anyone, and a GitHub alert
+// (`> [!NOTE]`) is the writer's own text. Only the quotation's own paragraphs are its words: code in it is not, and a
+// quotation inside it is read on its own. Pure; reads the Markdown tree.
+import { spanOf, type MarkdownNode } from "../markdown-node.ts";
+import { lineStarts } from "../position.ts";
+
+/** quote: the quotation's words without the `>` marks. passage: the quotation and its dash line as written, where a source would be. */
+export type BlockQuotation = { readonly offset: number; readonly quote: string; readonly passage: string };
+
+/**
+ * An em dash, a horizontal bar or an en dash, once or twice, then a name: not a lower-case word, which goes on a sentence
+ * (— and then it slipped). A single `-` opens a list item, and `--` opens an email signature.
+ */
+const DASH_LINE = /^[—―–]{1,2}[\t\p{Zs}]*(?!\p{Ll})\p{L}/u;
+/** Longer than this, a line opening with a dash is a sentence, not a name and a work. */
+const MAX_ATTRIBUTION_CHARS = 120;
+const QUOTE_MARKS = /^(?:[ \t]*>[ \t]?)+/u;
+const ALERT = /^\[![A-Za-z]+\]/u;
+/** Japanese and Chinese text runs on across a line break; anything else is separated by a space. */
+const CJK = String.raw`[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}、。「」『』（）！？：；]`;
+const CJK_END = new RegExp(`${CJK}$`, "u");
+const CJK_START = new RegExp(`^${CJK}`, "u");
+
+type Line = { readonly offset: number; readonly text: string };
+
+/**
+ * A line that ends like a sentence is the writer going on (――私はこの言葉を思い出す。, — Not yet. Give it ten minutes.),
+ * not a name and a work. A period after a lower-case word ends a sentence; one after an initial or "Inc." does not.
+ */
+const SENTENCE_END = /(?:[。！？!?]|(?:^|[\s\p{P}])\p{Ll}+\.)$/u;
+
+const isDashLine = (text: string): boolean => DASH_LINE.test(text) && [...text].length <= MAX_ATTRIBUTION_CHARS && !SENTENCE_END.test(text);
+
+/** Each non-blank line of a node without its `>` marks, at the place in source where its words start. */
+const linesOf = (source: string, node: MarkdownNode): Line[] => {
+  const span = spanOf(node);
+  if (span === undefined) return [];
+  const text = source.slice(span.start, span.end);
+  const starts = lineStarts(text);
+  return text.split("\n").flatMap((raw, index) => {
+    const marks = QUOTE_MARKS.exec(raw)?.[0].length ?? 0;
+    const words = raw.slice(marks);
+    const indent = words.length - words.trimStart().length;
+    return words.trim() === "" ? [] : [{ offset: span.start + (starts[index] ?? 0) + marks + indent, text: words.trim() }];
+  });
+};
+
+/** What goes between two lines: nothing where Japanese or Chinese runs on, a space otherwise. */
+const separator = (before: string, after: string): string => (before === "" || CJK_END.test(before) || CJK_START.test(after) ? "" : " ");
+
+/** Lines joined as the reader reads them. */
+const joined = (lines: readonly Line[]): string => lines.map((line) => line.text).reduce((text, next) => `${text}${separator(text, next)}${next}`, "");
+
+/** The dash line of a paragraph that is only that line. */
+const dashParagraph = (source: string, node: MarkdownNode | undefined): string | undefined => {
+  const lines = node?.type === "paragraph" ? linesOf(source, node) : [];
+  const only = lines.length === 1 ? lines[0]?.text : undefined;
+  return only !== undefined && isDashLine(only) ? only : undefined;
+};
+
+const quotationOf = (source: string, quote: MarkdownNode, next: MarkdownNode | undefined): BlockQuotation | undefined => {
+  const children = quote.children ?? [];
+  const lines = children.filter((child) => child.type === "paragraph").flatMap((paragraph) => linesOf(source, paragraph));
+  const last = children.at(-1)?.type === "paragraph" ? lines.at(-1) : undefined;
+  if (ALERT.test(lines[0]?.text ?? "")) return undefined;
+  const inside = last !== undefined && isDashLine(last.text);
+  const attribution = inside ? last.text : dashParagraph(source, next);
+  const body = inside ? lines.slice(0, -1) : lines;
+  const first = body[0];
+  const span = spanOf(quote);
+  if (attribution === undefined || first === undefined || span === undefined) return undefined;
+  return { offset: first.offset, quote: joined(body), passage: `${source.slice(span.start, span.end)}\n${attribution}` };
+};
+
+/**
+ * Every block quotation given to someone by a dash line. One that is not given to anyone is read for a quotation inside
+ * it. Walks with its own stack: Markdown nests without limit.
+ */
+export const blockQuotations = (root: MarkdownNode, source: string): BlockQuotation[] => {
+  const found: BlockQuotation[] = [];
+  const pending: MarkdownNode[] = [root];
+  for (let node = pending.pop(); node !== undefined; node = pending.pop()) {
+    const children = node.children ?? [];
+    const given = children.map((child, index) => (child.type === "blockquote" ? quotationOf(source, child, children[index + 1]) : undefined));
+    given.forEach((quotation) => {
+      if (quotation !== undefined) found.push(quotation);
+    });
+    children
+      .filter((_child, index) => given[index] === undefined)
+      .toReversed()
+      .forEach((child) => pending.push(child));
+  }
+  return found.toSorted((left, right) => left.offset - right.offset);
+};

package/src/detectors/bracket-label.ts

@@ -0,0 +1,58 @@
+/**
+ * 丸括弧の閉じを、開きを持たない印として読むかどうか。印に使うのは丸括弧だけなので、呼ぶ側が丸括弧の閉じに限る。
+ * text は節の文字列で、offset は閉じの位置。
+ */
+import { escapeRegExp } from "../orthography.ts";
+
+/** 行の頭か空白・句読点の後ろに書いた、三文字までの印（「1)」「a)」「事例）」「※）」）。顔文字の「:)」も同じ形。 */
+const LABEL_TOKEN_BEFORE = /(?:^|[\s、。,;:：])[^\s()（）[\]［］「」『』]{1,3}[ \t\u3000]?$/u;
+
+/** 数の後ろの閉じ（「事例2）及び事例3）」）。 */
+const NUMBER_BEFORE = /[\d０-９]$/u;
+
+/** 句読点の後ろの、字の後ろに数を付けた印（「以下、事例5）」）。group 1 は数の前の字（「事例」）。 */
+const NUMBERED_LABEL_BEFORE = /[、。,;:：] ?([^\s\d０-９()（）[\]［］「」『』、。,;:：]{1,3})[\d０-９]{1,3}$/u;
+
+const ROUND_OPEN = new Set(["（", "("]);
+const ROUND_CLOSE = new Set(["）", ")"]);
+
+const lineBefore = (text: string, offset: number): string => text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset);
+
+const isLabelToken = (text: string, offset: number): boolean => LABEL_TOKEN_BEFORE.test(lineBefore(text, offset));
+
+/** 開いている丸括弧が無いときの閉じが、印の形をしているか。 */
+export const isLabelClose = (text: string, offset: number): boolean => isLabelToken(text, offset) || NUMBER_BEFORE.test(lineBefore(text, offset));
+
+const restOfLine = (text: string, offset: number): string => {
+  const end = text.indexOf("\n", offset);
+  return text.slice(offset + 1, end === -1 ? text.length : end);
+};
+
+/** offset の後ろ、同じ行のうちの、印の形でない閉じのうち、それより前に開いた丸括弧を閉じるものの数。間の丸括弧の組は数えない。 */
+const outerClosesLaterOnLine = (text: string, offset: number): number => {
+  const depth = { inner: 0, outer: 0 };
+  restOfLine(text, offset)
+    .split("")
+    .forEach((mark, index) => {
+      if (ROUND_OPEN.has(mark)) depth.inner += 1;
+      if (!ROUND_CLOSE.has(mark)) return;
+      if (depth.inner > 0) depth.inner -= 1;
+      else if (!isLabelClose(text, offset + 1 + index)) depth.outer += 1;
+    });
+  return depth.outer;
+};
+
+/** 節のどこかの行の頭（箇条の印の後ろも含む）に、同じ字で始まる番号の印（「- 事例1）」）を書いているか。 */
+const usedAsLineLabel = (text: string, stem: string): boolean =>
+  new RegExp(`^[ \\t\u3000]*(?:[-*+・][ \\t\u3000]*)?${escapeRegExp(stem)}[\\d０-９]{1,3}[)）]`, "mu").test(text);
+
+/**
+ * 開いた丸括弧の中の印（「（…以下、事例5）まで同じ。）」の「事例5）」）。三つがそろうときだけ印と読む: 句読点の後ろの、字に数を
+ * 付けた形であること。同じ字の番号の印を、節のどこかの行の頭で使っていること。同じ行の後ろの閉じだけで、いま開いている
+ * 丸括弧（openRound 個）をすべて閉じられること。どれかが欠ければ、この閉じで括弧を閉じる（「（項目 1）を確認した）」は
+ * 余分な閉じを指す）。
+ */
+export const isLabelInAside = (text: string, offset: number, openRound: number): boolean => {
+  const stem = NUMBERED_LABEL_BEFORE.exec(lineBefore(text, offset))?.[1];
+  return stem !== undefined && usedAsLineLabel(text, stem) && outerClosesLaterOnLine(text, offset) >= openRound;
+};

package/src/detectors/citation-entry.ts

@@ -45,17 +45,32 @@ export const namesEntry = (entryKey: string, citedKey: string): boolean => {
   return !LATIN.test(citedKey) && [...surname].length >= MIN_PREFIX_SURNAME && entryKey.startsWith(citedKey);
 };
 
+/**
+ * namesEntry, and also a one-character Japanese surname (森, 林) against the full name it heads (森達也) when no other entry
+ * of that year starts with it: the list then leaves no other work it could name, where 林 beside 林田太郎 and 林正 does.
+ */
+export const namesEntryAmong =
+  (entryKeys: readonly string[]) =>
+  (entryKey: string, citedKey: string): boolean => {
+    if (namesEntry(entryKey, citedKey)) return true;
+    if (LATIN.test(citedKey) || !entryKey.startsWith(citedKey)) return false;
+    return entryKeys.filter((key) => key.startsWith(citedKey)).length === 1;
+  };
+
 const numberedSide = (entries: readonly ReferenceEntry[], marks: readonly CitationMark[]): Side => ({
   entries: entries.flatMap((entry) => (entry.number === undefined ? [] : [{ key: String(entry.number), start: entry.start }])),
   citations: marks.filter((mark) => NUMBERED_STYLES.has(mark.style)).map((mark) => ({ mark, keys: mark.numbers.map(String) })),
   names: (entryKey, citedKey) => entryKey === citedKey,
 });
 
-const authorYearSide = (entries: readonly ReferenceEntry[], marks: readonly CitationMark[]): Side => ({
-  entries: entries.flatMap((entry) => (entry.authorYear === undefined ? [] : [{ key: keyOf(entry.authorYear), start: entry.start }])),
-  citations: marks.filter((mark) => mark.style === "author-year").map((mark) => ({ mark, keys: mark.authorYears.map(keyOf) })),
-  names: namesEntry,
-});
+const authorYearSide = (entries: readonly ReferenceEntry[], marks: readonly CitationMark[]): Side => {
+  const keyed = entries.flatMap((entry) => (entry.authorYear === undefined ? [] : [{ key: keyOf(entry.authorYear), start: entry.start }]));
+  return {
+    entries: keyed,
+    citations: marks.filter((mark) => mark.style === "author-year").map((mark) => ({ mark, keys: mark.authorYears.map(keyOf) })),
+    names: namesEntryAmong(keyed.map((entry) => entry.key)),
+  };
+};
 
 export const sideSlips = (side: Side): CitationSlip[] => {
   if (side.entries.length < MIN_ENTRIES || side.citations.length === 0) return [];

package/src/detectors/code-before.ts

@@ -0,0 +1,14 @@
+// Whether inline code stands right before a place in the text. Code is masked to blanks before the text is read, so a word
+// after `explain` looks like the head of a sentence, and より after `relaxed` looks like the adverb. Pure.
+
+/**
+ * Whether the last mark before offset on the same line, past spaces, closes inline code (`relaxed` より). prose is the
+ * source with code masked; a backtick it keeps (\` escaped, or one left unclosed) is text, not code.
+ */
+export const followsInlineCode = (source: string, prose: string | undefined, offset: number): boolean => {
+  if (prose === undefined) return false;
+  const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+  const before = source.slice(lineStart, Math.max(lineStart, offset)).trimEnd();
+  const mark = lineStart + before.length - 1;
+  return before.endsWith("`") && prose.charAt(mark) !== "`";
+};

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）。どちらが正しいかは決めず、少ないほうを指す。
@@ -77,7 +78,7 @@ export const formsOf = (doc: ProseDocument): CurrencyForm[] =>
   );
 
 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 },
+  }));