chaffjs 0.23.0 → 0.24.0

package/src/detectors/ime-residue.ts

@@ -0,0 +1,37 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// A single Latin letter left inside a Japanese word by the input method (おもしrおい, 対応sた): a key pressed and not converted.
+
+/** One stray letter, and where it is in the text. */
+export type StrayLetter = { readonly offset: number; readonly letter: string };
+
+// Hiragana or kanji before (after katakana a letter is a label: サイズm, プランb), kana after.
+const STRAY = /(?<=[\p{Script=Hiragana}\p{Script=Han}々])[a-z](?=[\p{Script=Hiragana}\p{Script=Katakana}ー])/gu;
+/** Marks that make the run around the letter a path, an address or an assignment (/docs/あaい, a=b). */
+const PATH_MARK = /[/\\=@#]/u;
+
+const runBefore = (text: string, offset: number): string => text.slice(0, offset).split(/\s/u).at(-1) ?? "";
+
+/**
+ * One lower-case letter between Japanese: hiragana or kanji before, kana after. A letter followed by a particle names
+ * something (変数xが, まずxを, をxで), so it is left alone; the particles come from the lexicon.
+ */
+export const strayLettersIn = (text: string, particles: readonly string[]): StrayLetter[] =>
+  [...text.matchAll(STRAY)].flatMap((match) => {
+    const namesSomething = particles.some((particle) => text.startsWith(particle, match.index + 1));
+    return namesSomething || PATH_MARK.test(runBefore(text, match.index)) ? [] : [{ offset: match.index, letter: match[0] }];
+  });
+
+export const imeResidue: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const particles = (doc.lexicons["case-particle"] ?? []).map((entry) => entry.pattern);
+  return strayLettersIn(text, particles).map((stray) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, stray.offset, stray.offset + 1),
+    values: { letter: stray.letter, offset: stray.offset },
+  }));
+};

package/src/detectors/lexicon.ts

@@ -212,15 +212,24 @@ export const repeatedConjunction: Detector = (doc, options): Finding[] => {
     });
 };
 
+/**
+ * 書き手が書いた語。引用符の中だけの語（words such as "delves" and "pivotal"）は、例に挙げたか人の言葉を引いたもの。
+ * 品詞があれば当たった語の並びごとに見る（活用した形も原形で当たる）。無ければ字で照らす。
+ */
+const writtenIn = (sentence: Sentence, entry: LexiconEntry): boolean =>
+  sentence.tokens === undefined || entry.tokens === undefined || entry.tokens.length === 0
+    ? entryIn(sentence, entry) && !onlyQuoted(sentence, entry)
+    : entryRanges(sentence, entry).some((range) => !quotedRange(sentence, range));
+
 /**
  * AI 生成の signal。1 つでは何も言えないので、重みを足し合わせて文書の点にする。
  * 単独で断じない。§20.2 の複合シグナルの入口で、これだけで「AI が書いた」とは言わない。
  */
 export const aiTell: Detector = (doc, options): Finding[] => {
   const entries = [...new Map((options.lexicon ?? []).map((entry) => [entry.pattern.toLowerCase(), entry])).values()];
-  const found = entries.filter((entry) => doc.sentences.some((sentence) => entryIn(sentence, entry)));
+  const found = entries.filter((entry) => doc.sentences.some((sentence) => writtenIn(sentence, entry)));
   const score = Math.round(found.reduce((sum, entry) => sum + (entry.weight ?? 1), 0) * 10);
-  const first = doc.sentences.find((sentence) => found.some((entry) => entryIn(sentence, entry)));
+  const first = doc.sentences.find((sentence) => found.some((entry) => writtenIn(sentence, entry)));
   if (first === undefined || score <= options.limit) return [];
   return [
     {

package/src/detectors/lookalike-character.ts

@@ -0,0 +1,75 @@
+import type { Detector, Finding, Span } from "../plugin.ts";
+import { codePointName } from "./invisible-character.ts";
+
+/**
+ * A character that looks like a common one but is another code point, so search, sorting and a dictionary miss it.
+ * radical: a Kangxi or supplementary radical (⼈ U+2F08 for 人), from PDF text or an input method's radical list.
+ * compatibility: a CJK compatibility ideograph (or one of its supplement) that Unicode maps to a unified one (樂 U+F914 for 樂).
+ * decomposed: a letter and a separate combining mark (か + U+3099 for が, e + U+0301 for é), from file names or text
+ * copied on macOS. spacing-mark: kana followed by the spacing ゛ or ゜, typed in place of the combined letter.
+ */
+export type LookalikeKind = "radical" | "compatibility" | "decomposed" | "spacing-mark";
+
+export type Lookalike = { readonly span: Span; readonly kind: LookalikeKind; readonly written: string; readonly usual: string };
+
+const RADICAL = /[\u2E80-\u2EFF\u2F00-\u2FDF]/u;
+const COMPATIBILITY = /[\uF900-\uFAFF\u{2F800}-\u{2FA1F}]/u;
+/** A letter or mark base and the combining marks after it. */
+const WITH_MARKS = /\P{M}\p{M}+/gu;
+/** Kana followed by the spacing voiced or semi-voiced mark (か゛, は゜). */
+const SPACING_MARK = /[\p{Script=Hiragana}\p{Script=Katakana}][゛゜]/gu;
+const COMBINING_OF: Readonly<Record<string, string>> = { "゛": "゙", "゜": "゚" };
+const SINGLE_CHAR = /[\u2E80-\u2EFF\u2F00-\u2FDF\uF900-\uFAFF\u{2F800}-\u{2FA1F}]/gu;
+
+/** A radical or compatibility ideograph, with the unified ideograph it stands for. One that maps to nothing is left alone. */
+const singleLookalikes = (source: string): Lookalike[] =>
+  [...source.matchAll(SINGLE_CHAR)].flatMap((match) => {
+    const written = match[0];
+    const radical = RADICAL.test(written);
+    const usual = written.normalize(radical ? "NFKC" : "NFC");
+    if (usual === written || (!radical && !COMPATIBILITY.test(written))) return [];
+    return [{ span: { start: match.index, end: match.index + written.length }, kind: radical ? "radical" : "compatibility", written, usual }];
+  });
+
+/** A base and combining marks that compose into one precomposed letter. Marks with no precomposed form are writing, not a slip. */
+const decomposedLookalikes = (source: string): Lookalike[] =>
+  [...source.matchAll(WITH_MARKS)].flatMap((match) => {
+    const usual = match[0].normalize("NFC");
+    if (Array.from(usual).length >= Array.from(match[0]).length) return [];
+    return [{ span: { start: match.index, end: match.index + match[0].length }, kind: "decomposed", written: match[0], usual }];
+  });
+
+/** Kana and a spacing ゛ or ゜ whose combining form makes one letter (か゛ → が). */
+const spacingMarkLookalikes = (source: string): Lookalike[] =>
+  [...source.matchAll(SPACING_MARK)].flatMap((match) => {
+    const [kana = "", mark = ""] = Array.from(match[0]);
+    const usual = `${kana}${COMBINING_OF[mark] ?? ""}`.normalize("NFC");
+    if (Array.from(usual).length !== 1) return [];
+    return [{ span: { start: match.index, end: match.index + match[0].length }, kind: "spacing-mark", written: match[0], usual }];
+  });
+
+export const lookalikesIn = (source: string): Lookalike[] =>
+  [...singleLookalikes(source), ...decomposedLookalikes(source), ...spacingMarkLookalikes(source)].toSorted(
+    (left, right) => left.span.start - right.span.start,
+  );
+
+const QUOTE_REACH = 20;
+
+const quoteOf = (source: string, span: Span): string =>
+  source
+    .slice(Math.max(0, span.start - QUOTE_REACH), span.end + QUOTE_REACH)
+    .replace(/\s+/gu, " ")
+    .trim();
+
+const codesOf = (text: string): string => Array.from(text).map(codePointName).join(" ");
+
+export const lookalikeCharacter: Detector = (doc): Finding[] =>
+  lookalikesIn(doc.source).map((lookalike) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteOf(doc.source, lookalike.span),
+    values: { written: lookalike.written, usual: lookalike.usual, code: codesOf(lookalike.written), offset: lookalike.span.start },
+    variant: lookalike.kind,
+  }));

package/src/detectors/lowercase-name.ts

@@ -0,0 +1,58 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// A word English always capitalises (a weekday, a month) written in lower case ("on monday"). The words come from the rule's
+// lexicon "calendar-name"; the pattern is the capitalised form.
+
+export type LowercaseName = { readonly offset: number; readonly written: string; readonly usual: string };
+
+/** Characters that make the word part of a name in code, a path, an address or a tag (monday.md, /july/, @friday, #june). */
+const NOT_PROSE_BESIDE = /[\p{L}\p{N}_/.@#:=-]/u;
+
+/** A period or colon ends the sentence or clause unless a name continues after it (monday.md, june:2). */
+const SENTENCE_STOP = /[.:]/u;
+const WORD_CHAR = /[\p{L}\p{N}_]/u;
+
+const joinsAfter = (text: string, end: number): boolean =>
+  SENTENCE_STOP.test(text.charAt(end)) ? WORD_CHAR.test(text.charAt(end + 1)) : NOT_PROSE_BESIDE.test(text.charAt(end));
+
+/** A value after a key or a field marker (day: monday, day = monday, "day": "monday", * * monday) is data, not prose. */
+const VALUE_MARK = /[:=*]/u;
+const STRAIGHT_QUOTE = /["']/u;
+const SPACE_OR_QUOTE = /[\s"']/u;
+/** How far back to look past spaces and quotes for the key's mark. */
+const VALUE_REACH = 8;
+
+const markBefore = (text: string, start: number): string =>
+  Array.from(text.slice(Math.max(0, start - VALUE_REACH), start))
+    .reverse()
+    .find((char) => !SPACE_OR_QUOTE.test(char)) ?? "";
+
+const isValue = (text: string, start: number): boolean => STRAIGHT_QUOTE.test(text.charAt(start - 1)) || VALUE_MARK.test(markBefore(text, start));
+
+const capitalOf = (word: string): string => `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
+
+export const lowercaseNamesIn = (text: string, names: readonly string[]): LowercaseName[] => {
+  const lower = new Map(names.map((name) => [name.toLowerCase(), capitalOf(name)]));
+  return [...text.matchAll(/\p{Ll}+/gu)].flatMap((match) => {
+    const usual = lower.get(match[0]);
+    const end = match.index + match[0].length;
+    if (usual === undefined || NOT_PROSE_BESIDE.test(text.charAt(match.index - 1)) || isValue(text, match.index) || joinsAfter(text, end)) return [];
+    return [{ offset: match.index, written: match[0], usual }];
+  });
+};
+
+export const lowercaseName: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return lowercaseNamesIn(
+    text,
+    (doc.lexicons["calendar-name"] ?? []).map((entry) => entry.pattern),
+  ).map((name) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, name.offset, name.offset + name.written.length),
+    values: { written: name.written, usual: name.usual, offset: name.offset },
+  }));
+};

package/src/detectors/registry/bare-comparative.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { bareComparative } from "../bare-comparative.ts";
+
+export const detector: Detector = bareComparative;

package/src/detectors/registry/calendar-name-case.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { lowercaseName } from "../lowercase-name.ts";
+
+export const detector: Detector = lowercaseName;

package/src/detectors/registry/generic-heading.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { genericHeading } from "../generic-heading.ts";
+
+export const detector: Detector = genericHeading;

package/src/detectors/registry/ime-residue.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { imeResidue } from "../ime-residue.ts";
+
+export const detector: Detector = imeResidue;

package/src/detectors/registry/lookalike-character.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { lookalikeCharacter } from "../lookalike-character.ts";
+
+export const detector: Detector = lookalikeCharacter;

package/src/detectors/registry/unit-spacing-consistency.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { unitSpacing } from "../unit-spacing.ts";
+
+export const detector: Detector = unitSpacing;

package/src/detectors/signals.ts

@@ -11,6 +11,7 @@ import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts"
 import { letteredIndexEntries } from "./lettered-index.ts";
 import { hasPredicateIn } from "./gram-predicate.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
+import { referenceListSpans } from "../reference-lists.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
 
 const PER = 1000;
@@ -250,9 +251,12 @@ const firstHits = (hits: readonly AcronymHit[]): Map<string, Hit> => {
   return seen;
 };
 
-/** 日付の中の月（SEP 01, 2022）は略語ではない。 */
-const outsideDates = (hits: readonly AcronymHit[], dates: readonly Span[]): AcronymHit[] =>
-  hits.filter(({ hit }) => !dates.some((span) => span.start <= hit.offset && hit.offset < span.end));
+/**
+ * 範囲の外の略語。日付の中の月（SEP 01, 2022）は略語ではない。文献一覧の誌名や会議名（Appeared in: LREC 2008.）は
+ * 引いた文献の書き方で、本文が説明する略語ではない。
+ */
+const outsideSpans = (hits: readonly AcronymHit[], spans: readonly Span[]): AcronymHit[] =>
+  hits.filter(({ hit }) => !spans.some((span) => span.start <= hit.offset && hit.offset < span.end));
 
 /**
  * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
@@ -300,11 +304,11 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const headings = doc.sections.map((section) => section.heading);
   const explainedAlone = (word: string): boolean =>
     common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt) || headings.some((heading) => expandsInHeading(heading, word, expandedAt));
-  const hits = acronymsOf(doc, notationOf(doc));
+  const hits = outsideSpans(acronymsOf(doc, notationOf(doc)), referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")));
   const unexplained = new Set([...firstHits(hits).keys()].filter((acronym) => !isExplained(acronym, explainedAlone)));
   // 日付を読むには文書の木を作る。上限に届かない文書では作らない。
   if (unexplained.size < options.limit) return [];
-  const bare = [...firstHits(outsideDates(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
+  const bare = [...firstHits(outsideSpans(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({
     rule: "undefined-acronym",

package/src/detectors/structure-tree.ts

@@ -6,6 +6,7 @@ import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
+import { isQuotedAlone } from "../quoted-span.ts";
 
 const QUOTE_LENGTH = 80;
 
@@ -42,22 +43,43 @@ const dayName = (doc: ProseDocument, day: unknown): string => {
   return doc.lexicons["weekday"]?.[index]?.pattern ?? String(index);
 };
 
-export const dateWeekdayMismatch: Detector = (doc): Finding[] =>
-  doc.structure === undefined
-    ? []
-    : weekdayMismatches(doc.structure).map((issue) => ({
-        rule: "date-weekday-mismatch",
-        severity: "error",
-        line: 0,
-        column: 0,
-        quote: quoteAt(doc.source, issue.offset),
-        values: {
-          date: String(issue.values["date"]),
-          written: dayName(doc, issue.values["written"]),
-          actual: dayName(doc, issue.values["actual"]),
-          offset: issue.offset,
-        },
-      }));
+const datedSpans = (tree: NonNullable<ProseDocument["structure"]>): DatedSpan[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+
+/** 引用符の中で日付の横にあってよい語は、曜日の一語だけ（"Monday, December 5, 2026"、「2026年12月5日（月）」）。 */
+const WEEKDAY_WORDS = 1;
+
+/**
+ * 引用符で日付だけを挙げたもの（"Monday, December 5, 2026" falls on a Saturday）は、誤りの例で、文書の日付ではない。
+ * from から until の日付の終わりまでを見る。
+ */
+const quotedDates = (doc: ProseDocument, from: DatedSpan | undefined, until: DatedSpan | undefined, wordsBesides = 0): boolean =>
+  from !== undefined && until !== undefined && isQuotedAlone(doc.source, { start: from.offset, end: until.end }, wordsBesides);
+
+const dateAt = (dates: readonly DatedSpan[], offset: number): number => dates.findIndex((date) => date.offset === offset);
+
+export const dateWeekdayMismatch: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const dates = datedSpans(doc.structure);
+  return weekdayMismatches(doc.structure)
+    .filter((issue) => {
+      const date = dates[dateAt(dates, issue.offset)];
+      return !quotedDates(doc, date, date, WEEKDAY_WORDS);
+    })
+    .map((issue) => ({
+      rule: "date-weekday-mismatch",
+      severity: "error",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: {
+        date: String(issue.values["date"]),
+        written: dayName(doc, issue.values["written"]),
+        actual: dayName(doc, issue.values["actual"]),
+        offset: issue.offset,
+      },
+    }));
+};
 
 /** 木の日付を、原文の位置と一緒に並べる。 */
 const datedPoints = (tree: NonNullable<ProseDocument["structure"]>): { offset: number; value: string }[] =>
@@ -99,9 +121,6 @@ export const totalMismatch: Detector = (doc): Finding[] =>
         values: { ...issue.values, offset: issue.offset },
       }));
 
-const datedSpans = (tree: NonNullable<ProseDocument["structure"]>): DatedSpan[] =>
-  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
-
 const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   connectors: (doc.lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
   openers: (doc.lexicons["range-opener"] ?? []).map((entry) => entry.pattern),
@@ -111,17 +130,23 @@ const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
 });
 
 /** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
-export const dateRangeReversed: Detector = (doc): Finding[] =>
-  doc.structure === undefined
-    ? []
-    : reversedRanges(doc.source, datedSpans(doc.structure), rangeWordsOf(doc)).map((issue) => ({
-        rule: "date-range-reversed",
-        severity: "warning",
-        line: 0,
-        column: 0,
-        quote: quoteAt(doc.source, issue.offset),
-        values: { ...issue.values, offset: issue.offset },
-      }));
+export const dateRangeReversed: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const dates = datedSpans(doc.structure);
+  return reversedRanges(doc.source, dates, rangeWordsOf(doc))
+    .filter((issue) => {
+      const start = dateAt(dates, issue.offset);
+      return !quotedDates(doc, dates[start], dates[start + 1]);
+    })
+    .map((issue) => ({
+      rule: "date-range-reversed",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+};
 
 const shareWordsOf = (doc: ProseDocument): ShareWords => ({
   labels: (doc.lexicons["share-label"] ?? []).map((entry) => entry.pattern),

package/src/detectors/technical-docs.ts

@@ -4,6 +4,7 @@
 // shell-prompt lexicons.
 import { codeFences, codeSpans, type CodeFence } from "./code-fences.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { escapeRegExp } from "../orthography.ts";
 import type { Detector, Finding, ProseDocument, Span, Token } from "../plugin.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
@@ -112,10 +113,22 @@ export const commandsIn = (heading: string): string[] => {
 const collapse = (text: string): string => text.replace(/\s+/gu, " ");
 const OPTION_CHAR = /[A-Za-z0-9_-]/u;
 
+/**
+ * A command with arguments whose program the code runs under its package's name: chaff grade as npx chaffjs grade,
+ * python -m venv as python3 -m venv. The arguments must follow as written.
+ */
+const showsUnderPackageName = (text: string, wanted: string): boolean => {
+  const [program = "", ...rest] = wanted.split(" ");
+  if (rest.length === 0) return false;
+  const pattern = `(?<![A-Za-z0-9_.-])${escapeRegExp(program)}[A-Za-z0-9_.-]* ${rest.map(escapeRegExp).join(" ")}(?![A-Za-z0-9_-])`;
+  return new RegExp(pattern, "u").test(text);
+};
+
 /** Whether the code holds the command as a whole word: --force is not --force-with-lease, init is not initial. */
 export const showsCommand = (code: string, command: string): boolean => {
   const text = collapse(code);
   const wanted = collapse(command.trim());
+  if (showsUnderPackageName(text, wanted)) return true;
   const state = { at: text.indexOf(wanted) };
   while (state.at !== -1) {
     const before = text.charAt(state.at - 1);

package/src/detectors/unit-spacing.ts

@@ -0,0 +1,71 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { formMinority } from "./form-minority.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// One document writing a number and a unit symbol both with a space between them ("5 GB") and without ("5GB"). Neither is
+// called right; per unit, the less common way is reported. The symbols come from each language's lexicon "unit-symbol".
+
+/** A number and its unit as written. form is "spaced" or "touching". */
+export type WrittenQuantity = { readonly offset: number; readonly written: string; readonly unit: string; readonly form: string };
+
+/** The less common way for one unit, with an example of the usual way and how many quantities of that unit there are. */
+export type UnitMinority = { readonly odd: WrittenQuantity; readonly usual: string; readonly count: number; readonly of: number };
+
+// Grouping commas, then at most one decimal point: 1.2.3 is a version, not a number.
+const NUMBER = "[0-9]+(?:,[0-9]{3})*(?:\\.[0-9]+)?";
+// A plain space, a no-break space or a narrow no-break space (the SI brochure's thin space between number and unit).
+const GAP = "[ \\u00A0\\u202F]?";
+
+/**
+ * Numbers followed by a unit symbol, at most one space between. The number must not be part of a word, a version or an
+ * address (v1.2GB, x86, 1.2.3GB), nor follow a hyphen: "10-8 cm" is as often a lost exponent as a range (5–10 GB, with
+ * an en dash, is read). The symbol must not run on into a word, a rate or a file name (5 GBit, 5 GB/s, 5GB.zip).
+ */
+export const quantitiesIn = (text: string, symbols: readonly string[]): WrittenQuantity[] => {
+  if (symbols.length === 0) return [];
+  const units = symbols
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+  const pattern = new RegExp(`(?<![A-Za-z0-9_.,/:#-])${NUMBER}(?<gap>${GAP})(?<unit>${units})(?![A-Za-z0-9_/]|\\.[A-Za-z0-9_])`, "gu");
+  return [...text.matchAll(pattern)].map((match) => ({
+    offset: match.index,
+    written: match[0],
+    unit: match.groups?.["unit"] ?? "",
+    form: match.groups?.["gap"] === "" ? "touching" : "spaced",
+  }));
+};
+
+const minorityOf = (ofUnit: readonly WrittenQuantity[], limit: number): UnitMinority[] => {
+  const minority = formMinority(ofUnit, limit);
+  if (minority === undefined) return [];
+  return minority.odd.map((quantity) => ({ odd: quantity, usual: minority.usual.written, count: minority.odd.length, of: ofUnit.length }));
+};
+
+/** Per unit, the quantities written the less common way. "5 GB" and "500ms" in one document are two units, each consistent. */
+export const unitMinorities = (quantities: readonly WrittenQuantity[], limit: number): UnitMinority[] =>
+  [...new Set(quantities.map((quantity) => quantity.unit))]
+    .flatMap((unit) =>
+      minorityOf(
+        quantities.filter((quantity) => quantity.unit === unit),
+        limit,
+      ),
+    )
+    .toSorted((left, right) => left.odd.offset - right.odd.offset);
+
+export const unitSpacing: Detector = (doc, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const quantities = quantitiesIn(
+    text,
+    (doc.lexicons["unit-symbol"] ?? []).map((entry) => entry.pattern),
+  );
+  return unitMinorities(quantities, options.limit).map(({ odd, usual, count, of }) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, odd.offset, odd.offset + odd.written.length),
+    values: { written: odd.written, usual, count, of, offset: odd.offset },
+  }));
+};

package/src/quoted-span.ts

@@ -41,5 +41,30 @@ export const quotedSpans = (text: string, marks: Marks = KAGI_MARKS): Span[] =>
 export const quotedIn = (sentence: Sentence, marks: Marks = KAGI_MARKS): Span[] =>
   quotedSpans(sentence.text, marks).map((span) => ({ start: sentence.span.start + span.start - 1, end: sentence.span.start + span.end + 1 }));
 
+const MARKS = /[\s\p{P}]+/u;
+const LETTERS = /^\p{L}+$/u;
+
+/** 記号と空白のあいだに残る語が、字だけの語で、多くとも allowed 個か。 */
+const holdsAtMost = (text: string, allowed: number): boolean => {
+  const words = text.split(MARKS).filter((word) => word !== "");
+  return words.length <= allowed && words.every((word) => LETTERS.test(word));
+};
+
+/**
+ * span だけを引いた引用符（"delves"、"?utm_source=chatgpt.com"、"October 26, 2026 – October 19, 2026"）の中か。
+ * 引用符が語だけを囲めば、その語は使ったのではなく例として挙げたもの。周りの記号と空白は語の一部に数えない。
+ * wordsBesides は、span のほかに引用符の中にあってよい語の数（日付なら曜日の一語）。
+ * 話した言葉の引用（"We ship on Monday, October 26," she said.）は語のほかの字を持つので当たらない。引用は一行の中だけを見る。
+ */
+export const isQuotedAlone = (text: string, span: Span, wordsBesides = 0): boolean => {
+  const lineStart = text.lastIndexOf("\n", span.start - 1) + 1;
+  const newline = text.indexOf("\n", span.end);
+  const line = text.slice(lineStart, newline === -1 ? text.length : newline);
+  const [start, end] = [span.start - lineStart, span.end - lineStart];
+  return quotedSpans(line, QUOTATION_MARKS).some(
+    (quoted) => quoted.start <= start && end <= quoted.end && holdsAtMost(`${line.slice(quoted.start, start)} ${line.slice(end, quoted.end)}`, wordsBesides),
+  );
+};
+
 /** inner が、spans のどれかにまるごと入っているか。 */
 export const isWithinAny = (spans: readonly Span[], inner: Span): boolean => spans.some((span) => inner.start >= span.start && inner.end <= span.end);

package/src/structure/definition-use.ts

@@ -4,7 +4,13 @@ import { inDocumentOrder } from "./issues.ts";
 
 // 定義した語が本文で使われているか、定義より前に使われていないか。どちらも木の定義と、本文の文の字面だけで決まる。
 
-export type DefinedTerm = { readonly term: string; readonly span: Span; readonly line: number; readonly inline: boolean };
+/** bare は、定義の語（means・以下…という・the）の無い括弧の引用（("Seller")）。例を引く括弧と同じ形。 */
+export type DefinedTerm = { readonly term: string; readonly span: Span; readonly line: number; readonly inline: boolean; readonly bare?: boolean };
+
+/** 文書の位置 [start, end) の語が、使ったのではなく引用符で例として挙げただけか。 */
+export type Mentioned = (start: number, end: number) => boolean;
+
+const NEVER_MENTIONED: Mentioned = () => false;
 
 /** 本文の一続き（文）。start は文書の中の位置。 */
 export type BodyText = { readonly start: number; readonly text: string };
@@ -30,7 +36,8 @@ export const definedTerms = (tree: StructureNode): DefinedTerm[] =>
             .replaceAll(EMPHASIS_MARKS, "")
             .trim()
         : "";
-    return isTerm(term) ? [{ term, span: node.span, line: node.line, inline: node.attrs["placement"] === "inline" }] : [];
+    const bare = node.attrs["form"] === "bare" ? { bare: true } : {};
+    return isTerm(term) ? [{ term, span: node.span, line: node.line, inline: node.attrs["placement"] === "inline", ...bare }] : [];
   });
 
 const LATIN_EDGE = /^[\p{Script=Latin}\p{N}]|[\p{Script=Latin}\p{N}]$/u;
@@ -56,11 +63,23 @@ const termPattern = (term: string, caseMatch: CaseMatch): RegExp => {
 
 const inside = (offset: number, spans: readonly Span[]): boolean => spans.some((span) => span.start <= offset && offset < span.end);
 
-/** 語の現れ（文書の中の位置）を順に。定義そのもの（"Seller" means、(the "Seller")）の中の現れは使用に数えない。 */
-export const usesOf = (term: string, texts: readonly BodyText[], definitionSpans: readonly Span[], caseMatch: CaseMatch = "loose"): number[] => {
+/**
+ * 語の現れ（文書の中の位置）を順に。定義そのもの（"Seller" means、(the "Seller")）の中の現れは使用に数えない。
+ * mentioned が言う現れ（引用符で例として挙げただけ）も数えない。
+ */
+export const usesOf = (
+  term: string,
+  texts: readonly BodyText[],
+  definitionSpans: readonly Span[],
+  caseMatch: CaseMatch = "loose",
+  mentioned: Mentioned = NEVER_MENTIONED,
+): number[] => {
   const pattern = termPattern(term, caseMatch);
   return texts.flatMap((body) =>
-    [...body.text.matchAll(pattern)].map((match) => body.start + match.index).filter((offset) => !inside(offset, definitionSpans)),
+    [...body.text.matchAll(pattern)]
+      .filter((match) => !mentioned(body.start + match.index, body.start + match.index + match[0].length))
+      .map((match) => body.start + match.index)
+      .filter((offset) => !inside(offset, definitionSpans)),
   );
 };
 
@@ -78,10 +97,20 @@ const groupsOf = (terms: readonly DefinedTerm[]): TermGroup[] => {
 };
 
 /** 定義したのに、定義の外で一度も使っていない語。同じ語の定義が二つあれば、最初の一つだけを言う（二つ目は duplicate-definition）。 */
-export const unusedDefinitions = (terms: readonly DefinedTerm[], texts: readonly BodyText[]): DefinedTerm[] =>
-  groupsOf(terms)
-    .filter((group) => usesOf(group.first.term, texts, group.spans).length === 0)
+export const unusedDefinitions = (terms: readonly DefinedTerm[], texts: readonly BodyText[], mentioned: Mentioned = NEVER_MENTIONED): DefinedTerm[] => {
+  const groups = groupsOf(terms);
+  const examples = quotesExamples(groups, texts, mentioned);
+  return groups
+    .filter((group) => !(examples && group.first.bare === true) && usesOf(group.first.term, texts, group.spans).length === 0)
     .map((group) => group.first);
+};
+
+/**
+ * 定義の語の無い括弧の引用（("Seller")）を、文書が一つも本文で使っていなければ、それは定義ではなく例の引用
+ * （Plain verbs, not metaphors ("silently fails")）。引用符で挙げただけの現れは使用に数えない。
+ */
+const quotesExamples = (groups: readonly TermGroup[], texts: readonly BodyText[], mentioned: Mentioned): boolean =>
+  !groups.some((group) => group.first.bare === true && usesOf(group.first.term, texts, group.spans, "loose", mentioned).length > 0);
 
 /** offset を含む文。texts は start の昇順で、二分探索で引く。 */
 const sentenceAt = (texts: readonly BodyText[], offset: number): BodyText | undefined => {
@@ -118,13 +147,16 @@ const isDistinctive = (term: string): boolean => CAPITAL_OR_NON_LATIN.test(term)
  * 文の途中で括弧に入れて定義した語（(the "Seller")、以下「甲」という）を、その定義の文より前で使っている所。最初の一つだけ。
  * 定義の文の中の現れ（株式会社GovTech東京（以下「GovTech東京」という。））は、定義する名前そのものなので数えない。札の文も数えない。
  * 定義の条（"Seller" means、「甲」とは）は条の並びの頭にも終わりにも置く書き方があるので、前で使っても言わない。
+ * 定義の語の無い括弧の引用（("The key point is")）は例の引用と同じ形なので、その語を引用符で挙げただけの現れ
+ * （Its sentences open with "The key point is"）は使用ではない。定義の語のある定義（(the "Seller")、以下「買主」という）は、
+ * 引用符に入れた現れ（The "Seller" ships）も使用。
  */
-export const usesBeforeDefinition = (terms: readonly DefinedTerm[], texts: readonly BodyText[]): TermUse[] =>
+export const usesBeforeDefinition = (terms: readonly DefinedTerm[], texts: readonly BodyText[], mentioned: Mentioned = NEVER_MENTIONED): TermUse[] =>
   groupsOf(terms)
     .filter((group) => group.first.inline && isDistinctive(group.first.term))
     .flatMap(({ first: defined, spans }) => {
       const defining = sentenceAt(texts, defined.span.start)?.start ?? defined.span.start;
-      const uses = usesOf(defined.term, texts, spans, "exact");
+      const uses = usesOf(defined.term, texts, spans, "exact", defined.bare === true ? mentioned : NEVER_MENTIONED);
       const first = uses.find((offset) => !isLabel(sentenceAt(texts, offset), defined.term));
       return first !== undefined && first < defining ? [{ term: defined, offset: first }] : [];
     });