chaffjs 0.28.0 → 0.30.0

package/src/derived/working-hours.ts

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

package/src/detectors/acronym-context.ts

@@ -9,8 +9,8 @@ import { seriesLabelSpans } from "./series-label.ts";
 
 /**
  * 大文字の語が略語ではなく、決まった書き方の一部として読める所（3:30 PM、1pm ET、USD 1,000、Kansas City, MO 64108）。
- * どれも閉じた集合で、しかも隣の数字があるときだけ認める。PM（project manager）、CT、CA（certificate authority）は
- * 数字の隣でなければ略語のまま数える。語は言語パッケージの語彙表から読み、書き方の組み立てだけをここに置く。
+ * どれも閉じた集合で、しかも隣の数字（州は地名でもよい）があるときだけ認める。PM（project manager）、CT、CA（certificate authority）は
+ * その隣でなければ略語のまま数える。語は言語パッケージの語彙表から読み、書き方の組み立てだけをここに置く。
  */
 
 type Span = { readonly start: number; readonly end: number };
@@ -75,6 +75,13 @@ const titledName = (titles: string): readonly RegExp[] => [
   new RegExp(String.raw`(?<![\p{L}\p{N}_])${titles}\s+${SURNAME_IN_CAPITALS}${GIVEN_NAME_AFTER}`, "gu"),
 ];
 
+/**
+ * 郵便番号の無い所在地（Chicago, IL、Charleston, SC and…、Washington, DC: Association…）。頭が大文字の地名と読点の後ろで、
+ * 文や行の終わり・区切り・小文字の語が続くときだけ州と読む。数字や大文字の語が続くもの（Berkeley, CA 947、Sales, PA Team）は外さない。
+ */
+const placeAndState = (states: string): RegExp =>
+  new RegExp(String.raw`(?<=\p{Lu}\p{Ll}[\p{L}'’.-]*,\s+)${states}(?=[ \t]*(?:\r?\n|$)|[,.;:)\]!?]|\s+\p{Ll})`, "gu");
+
 // 強調の記号は空白に置き換えてある（**3:30** PM）ので、部品の間の空白は数を問わない。
 const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`${CLOCK_12}\s*${oneOf(words.meridiem)}`, "gu"),
@@ -82,6 +89,7 @@ const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`${oneOf(words.currencies)}\s*[$€£¥]?${AMOUNT}`, "gu"),
   new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(words.currencies)}`, "gu"),
   new RegExp(String.raw`,\s+${oneOf(words.usStates)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
+  placeAndState(oneOf(words.usStates)),
   new RegExp(oneOf(words.emphasis), "gu"),
   ...numberedPatterns(words),
   new RegExp(String.raw`(?<![\p{L}\p{N}_])${oneOf(words.honorifics)}\s+${SURNAME_IN_CAPITALS}`, "gu"),

package/src/detectors/acronym-expansion.ts

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

package/src/detectors/address-word.ts

@@ -0,0 +1,9 @@
+// Whether a word is part of an address or a file name rather than a word of the sentence. Pure.
+
+/** A word joined to a dot, an at sign or a slash is part of an address or a file name (github.com, user@example), spelled as it must be. */
+const ADDRESS_NEIGHBOUR = /[.@/\\_]/u;
+const WORD_CHAR = /\w/u;
+
+/** Whether text[start, end) is joined to an address mark before it, or to one followed by more of the address after it. */
+export const isPartOfAddress = (text: string, start: number, end: number): boolean =>
+  ADDRESS_NEIGHBOUR.test(text.charAt(start - 1)) || (ADDRESS_NEIGHBOUR.test(text.charAt(end)) && WORD_CHAR.test(text.charAt(end + 1)));

package/src/detectors/agreement-slip.ts

@@ -116,9 +116,15 @@ const mayBeNoun = (token: Token): boolean => token.features?.["AlsoNoun"] === "Y
 const mayBeVerb = (determiner: Determiner, modifiers: readonly Token[], noun: Token, next: Token | undefined, finite: ReadonlySet<string>): boolean =>
   noun.features?.["AlsoVerb"] === "Yes" && !(next !== undefined && finite.has(lower(next))) && (standsAlone(determiner) || modifiers.some(mayBeNoun));
 
+/** 冠詞は名詞句の頭に立つ。形容詞や数の後ろの a は、記号の名前（the eight 3-hourly a indices）。 */
+const AFTER_MODIFIER = new Set(["ADJ", "NUM"]);
+
+const isLetterName = (tokens: readonly Token[], at: number, determiner: Determiner): boolean =>
+  isArticle(determiner.head) && determiner.head.surface.length === 1 && AFTER_MODIFIER.has(tokens[at - 1]?.pos ?? "");
+
 const numberSlipAt = (source: string, tokens: readonly Token[], at: number, lists: AgreementLists): Slip | undefined => {
   const determiner = determinerAt(tokens, at, lists);
-  if (determiner === undefined || isNamePart(tokens, at)) return undefined;
+  if (determiner === undefined || isNamePart(tokens, at) || isLetterName(tokens, at, determiner)) return undefined;
   const modifiers = modifiersAfter(tokens, at + determiner.length, lists.count);
   if (modifiers === undefined || !readsAsDeterminer(determiner, modifiers)) return undefined;
   const nounAt = at + determiner.length + modifiers.length;

package/src/detectors/ai-phrasing.ts

@@ -5,6 +5,7 @@ import { entryIn, entryOpens } from "./lexicon-match.ts";
 import { contrastSentences, type ContrastWords } from "./contrast-frame.ts";
 import { placeholderSpans } from "./placeholder-text.ts";
 import { colonLeadIns } from "./list-lead-in.ts";
+import { followsInlineCode } from "./code-before.ts";
 
 // 生成文に多い形。語はどれも言語パッケージの語彙表が持ち、ここは形だけを知る。
 
@@ -68,8 +69,12 @@ export const openerDensity: Detector = (doc, options): Finding[] => densityFindi
  * 予告の文頭（重要なのは、Here's the thing）の数。limit は指摘に要る数。
  * 密度ではなく数で見る。人の記事も長さによらず 1 つ 2 つは書き、生成文は短い記事にも重ねる。
  */
+/** Where the sentence's first word starts: its span may begin with the blanks that masked code left. */
+const firstWordAt = (sentence: Sentence): number => sentence.span.start + sentence.text.length - sentence.text.trimStart().length;
+
 export const openerPile: Detector = (doc, options): Finding[] => {
-  const hits = openerHits(doc, options.lexicon ?? []);
+  // A sentence that opens with inline code (`explain` でも) opens with the code, not with the word after it.
+  const hits = openerHits(doc, options.lexicon ?? []).filter((hit) => !followsInlineCode(doc.source, doc.prose, firstWordAt(hit.sentence)));
   return hits.length === 0 || hits.length < options.limit ? [] : hits.map((hit) => findingOf(hit, { count: hits.length, limit: options.limit }));
 };
 

package/src/detectors/amount-range.ts

@@ -0,0 +1,54 @@
+// amount-range-reversed: a range of amounts whose upper end is below its lower end (structure/amount-range.ts). The amounts
+// are currency-notation's, read with amount-multiplier's words of scale and amount-short-scale's (k); the words of a range
+// are range-connector, range-opener, range-closer and amount-range-word; amount-change-word and amount-bound-label say
+// what makes a pair a change of price and what labels a bound.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { reversedAmountRanges, type AmountRangeWords, type RangeAmount } from "../structure/amount-range.ts";
+import type { ScaleWord } from "../structure/amount-scale.ts";
+import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
+import { AMOUNT, 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 shortScalesOf = (doc: ProseDocument): ScaleWord[] =>
+  (doc.lexicons["amount-short-scale"] ?? []).flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }]));
+
+const wordsOf = (doc: ProseDocument, scales: readonly ScaleWord[]): AmountRangeWords => ({
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+  openers: patternsOf(doc, "range-opener"),
+  closers: patternsOf(doc, "range-closer"),
+  changes: patternsOf(doc, "amount-change-word"),
+  lowers: patternsOf(doc, "amount-bound-label", "lower"),
+  uppers: patternsOf(doc, "amount-bound-label", "upper"),
+  links: patternsOf(doc, "amount-bound-label", "link"),
+  scales,
+  number: AMOUNT,
+});
+
+const rangeAmountsOf = (text: string, doc: ProseDocument, scales: readonly ScaleWord[]): RangeAmount[] =>
+  amountsIn(
+    text,
+    formsOf(doc),
+    scales.map((scale) => scale.word),
+  ).flatMap((amount) => {
+    const read = scaledAmountOf(text, amount, scales);
+    if (read === undefined) return [];
+    const position = amount.form.startsWith("before:") ? "before" : "after";
+    return [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit, position }];
+  });
+
+export const amountRange: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const scales = [...scaleWordsOf(doc), ...shortScalesOf(doc)];
+  return reversedAmountRanges(text, rangeAmountsOf(text, doc, scales), wordsOf(doc, scales)).map((issue) => ({
+    rule: "amount-range-reversed",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

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;
+};