chaffjs 0.27.1 → 0.29.0

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/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

@@ -0,0 +1,96 @@
+// 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, Lexicon, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.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;
+
+/** 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万円). */
+const leadingParts = (text: string, offset: number, words: readonly ScaleWord[]): string => {
+  if (words.length === 0) return "";
+  const scales = words.map((word) => escapeRegExp(word.word)).join("|");
+  const before = text.slice(Math.max(0, offset - LEADING_REACH), offset);
+  return new RegExp(`(?<![0-9０-９.,，])(?:${AMOUNT}(?:${scales}))+$`, "u").exec(before)?.[0] ?? "";
+};
+
+/** The written amount without its currency mark, which is on the side its form says. */
+const numberPart = (amount: WrittenAmount): string => {
+  const [position = "", ...mark] = amount.form.split(":");
+  const pattern = mark.join(":");
+  return position === "before" ? amount.written.trimStart().slice(pattern.length) : amount.written.trimEnd().slice(0, -pattern.length);
+};
+
+/** The largest word of scale written in the number (万 in 1億2,000万 is smaller than 億), undefined when there is none. */
+const unitOf = (number: string, words: readonly ScaleWord[]): number | undefined => {
+  const lower = number.toLowerCase();
+  const values = words.filter((word) => lower.includes(word.word.toLowerCase())).map((word) => word.value);
+  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) => 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 = proseAndTablesOf(doc);
+  const words = scaleWordsOf(doc);
+  const markers = doc.lexicons["approximate-marker"] ?? [];
+  const amounts = scaledAmountsOf(
+    text,
+    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,
+    column: 0,
+    quote: quoteAround(text, odd.offset, odd.offset + odd.written.length),
+    values: { written: odd.written.trim(), usual: usual.written.trim(), offset: odd.offset },
+  }));
+};

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/change-rate.ts

@@ -1,8 +1,9 @@
 // change-rate-mismatch: the reading half. Builds the figures, the rates and the words of structure/change-rate.ts from the
 // tree's quantities, the numbers counted with a word ("1,200 companies"), the calendar years, and the lexicons change-direction,
 // change-base, change-target, change-break, percent-unit and amount-multiplier.
-import type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode, Token } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
+import { startsOtherSubject } from "../structure/subject-change.ts";
 import { changeRateMismatches, type BaseMark, type Break, type Direction, type Figure, type Period, type Rate } from "../structure/change-rate.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
@@ -99,12 +100,24 @@ const directionsOf = (doc: ProseDocument): Direction[] =>
     return sign === undefined ? [] : [{ start, end, sign }];
   });
 
+/** The sentence's tokens, and the index of the token that starts at offset (-1 when none does). */
+const tokenAt = (doc: ProseDocument, offset: number): { readonly tokens: readonly Token[]; readonly index: number } => {
+  const tokens = doc.sentences.find((sentence) => sentence.span.start <= offset && offset < sentence.span.end)?.tokens ?? [];
+  return { tokens, index: tokens.findIndex((token) => token.span.start === offset) };
+};
+
+/** A word that may join two values ("and") does not when another subject follows it ("and costs were"). */
+const joinsTwoValues = (doc: ProseDocument, start: number): boolean => {
+  const { tokens, index } = tokenAt(doc, start);
+  return index < 0 || !startsOtherSubject(tokens, index);
+};
+
 /** Lexicon change-break (「は」, "and"), less the phrases of change-break-not (「上がり」 holds が but starts no subject). */
 const breaksOf = (doc: ProseDocument): Break[] =>
   spansWithout(doc, doc.lexicons["change-break"] ?? [], "change-break-not").map(({ start, end, entry }) => ({
     start,
     end,
-    beforeRateOnly: entry.group === "rate",
+    beforeRateOnly: entry.group === "rate" && joinsTwoValues(doc, start),
   }));
 
 /** A calendar year written alone or with a unit of calendar year (2025, 2025年, 2025年度), and not part of an amount ($2025). */

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) !== "`";
+};