chaffjs 0.32.0 → 0.34.0

package/src/detectors/number-unit.ts

@@ -135,12 +135,38 @@ export const unitGaps = (values: readonly Measured[]): UnitGap[] => {
 const unitsOf = (doc: ProseDocument): Set<string> =>
   new Set(UNIT_LEXICONS.flatMap((name) => (doc.lexicons[name] ?? []).flatMap((entry) => [entry.pattern, entry.pattern.toLowerCase()])));
 
-export const numberWithoutUnit: Detector = (doc: ProseDocument): Finding[] =>
-  unitGaps(measuredValues(doc.source, doc.prose ?? doc.source, unitsOf(doc))).map((gap) => ({
-    rule: "number-without-unit",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAt(doc.source, gap.value.offset),
-    values: { value: gap.value.written, name: gap.value.name, unit: gap.unit, offset: gap.value.offset },
-  }));
+/** Lexicon piece-count-column: the headings of a column that counts whatever its row is, and the units of a hired period. */
+export type PieceCount = { readonly columns: ReadonlySet<string>; readonly periods: ReadonlySet<string> };
+
+const WHOLE_NUMBER = /^\d[\d,]*$/u;
+const TABLE_KIND = /^table \d+: /u;
+
+/**
+ * A bare whole number in a quantity column whose other rows count a hired period (4 days, 2 nights): the count of a
+ * piece the row hires or buys (Child seat | 1), which has no unit to lose.
+ */
+export const isPieceCount = (gap: UnitGap, count: PieceCount): boolean =>
+  TABLE_KIND.test(gap.value.kind) &&
+  count.columns.has(gap.value.name.toLowerCase()) &&
+  count.periods.has(gap.unit.toLowerCase()) &&
+  WHOLE_NUMBER.test(gap.value.written.normalize("NFKC"));
+
+const pieceCountOf = (doc: ProseDocument): PieceCount => {
+  const entries = doc.lexicons["piece-count-column"] ?? [];
+  const patterns = (group: string): Set<string> => new Set(entries.filter((entry) => entry.group === group).map((entry) => entry.pattern.toLowerCase()));
+  return { columns: patterns("column"), periods: patterns("period") };
+};
+
+export const numberWithoutUnit: Detector = (doc: ProseDocument): Finding[] => {
+  const count = pieceCountOf(doc);
+  return unitGaps(measuredValues(doc.source, doc.prose ?? doc.source, unitsOf(doc)))
+    .filter((gap) => !isPieceCount(gap, count))
+    .map((gap) => ({
+      rule: "number-without-unit",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, gap.value.offset),
+      values: { value: gap.value.written, name: gap.value.name, unit: gap.unit, offset: gap.value.offset },
+    }));
+};

package/src/detectors/orthographic-variant.ts

@@ -8,6 +8,7 @@ import { furiganaSpans } from "../furigana.ts";
 import { acronymsIn, isCapitalsNotSpelling } from "../capitals-with-small.ts";
 import { isPartOfAddress } from "./address-word.ts";
 import { wholeWordRuns, type WholeWordRun } from "../whole-word-runs.ts";
+import { entriesForGenre } from "../lexicon-genres.ts";
 
 /**
  * A word found in the document: where it is, which sentence it is in, its key and spelling, how it is written when that differs, and
@@ -41,7 +42,8 @@ const IDIOM = "orthographic-variant-idiom";
 /** Lexicon: words the tokenizer cuts in one spelling and not the other (お客様, お客 and さま). Each is read whole, keyed by its group. */
 const WHOLE_WORD = "orthographic-variant-whole-word";
 
-const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+const patternsOf = (doc: ProseDocument, id: string, genre: string | undefined): string[] =>
+  entriesForGenre(doc.lexicons[id] ?? [], genre).map((entry) => entry.pattern);
 
 /**
  * Whether a stretch of the sentence is outside a quotation, the team's names and a reading in brackets (HTTP（えいちてぃーてぃーぴー）):
@@ -300,8 +302,8 @@ const cellPlace = (cell: TableCell, names: readonly string[]): Place => {
  */
 export const orthographicVariant: Detector = (doc, options): Finding[] => {
   const skips: Skips = {
-    skip: new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]),
-    idioms: new Set(patternsOf(doc, IDIOM)),
+    skip: new Set([...patternsOf(doc, DISTINCT, options.genre), ...patternsOf(doc, FUKUSHI, options.genre)]),
+    idioms: new Set(patternsOf(doc, IDIOM, options.genre)),
     wholeWords: new Map((doc.lexicons[WHOLE_WORD] ?? []).map((entry) => [entry.pattern, entry.group ?? entry.pattern])),
   };
   const names = doc.names ?? [];

package/src/detectors/orthography.ts

@@ -1,18 +1,26 @@
-import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { conjugatedStartsOutside } from "./conjugated-entry.ts";
 import { calendarRuns, calendarUnitsOf, type CalendarUnits } from "../calendar-number.ts";
 import { escapeRegExp, latinBoundaries, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
-import { minorityReport } from "../spacing-minority.ts";
+import { minorityReport, withoutSideOnTie } from "../spacing-minority.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStarts, type NameContext } from "../number-name.ts";
 import { isSpacedLocationPart, type FloorWords } from "../location-part.ts";
-import { isNameSeparator, type OrganizationWords } from "../name-separator.ts";
+import { isFieldSeparator, isNameSeparator, type OrganizationWords } from "../name-separator.ts";
 import { addressSpans, clockTimeSpans, identifierSpans, isInsideSpan } from "../spacing-code.ts";
 
+/** 書いた形の出現に、動詞の活用した形（行う → 行います）を足したもの。同じ位置は一度だけ。 */
+const avoidedStarts = (sentence: Sentence, entry: LexiconEntry, use: string): number[] => {
+  const written = occurrencesOutside(sentence.text, entry.pattern, use);
+  const conjugated = conjugatedStartsOutside(sentence, entry, use).filter((at) => !written.includes(at));
+  return [...written, ...conjugated].toSorted((left, right) => left - right);
+};
+
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
-  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ avoid: entry.pattern, use: entry.instead_of }]));
+  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ entry, avoid: entry.pattern, use: entry.instead_of }]));
   const hits = doc.sentences.flatMap((sentence) =>
-    pairs.flatMap((pair) => occurrencesOutside(sentence.text, pair.avoid, pair.use).map((at) => ({ sentence, at, pair }))),
+    pairs.flatMap((pair) => avoidedStarts(sentence, pair.entry, pair.use).map((at) => ({ sentence, at, pair }))),
   );
   if (hits.length === 0 || hits.length < options.limit) return [];
   return hits.map((hit) => ({
@@ -91,7 +99,7 @@ type SentenceCodes = {
  * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。コロンで書いた時刻（13:30）も同じ。
  * メールアドレス・URL の前後の境目も数えない（spacing-code.ts）。「予約番号 MN-48215 を」の番号の前後も、番号を文から区切る空白なので数えない。
  * 「本社 5階」のように名前の後ろに空白で区切った階・部屋の番号の前の空白も、所在の組の区切りなので数えない（location-part.ts）。
- * 「経営企画部 IR担当」のように名前だけを並べた行で、名前と名前を分ける空白も数えない（name-separator.ts）。
+ * 「経営企画部 IR担当」のように名前だけを並べた行で、名前と名前を分ける空白も、「所属：経済学科 1年」のように項目の値の組を分ける空白も数えない（name-separator.ts）。
  */
 const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, codes: SentenceCodes): boolean => {
   if (followsItemNumber(sentence.text, boundary, context.itemNumbers) || besideSpan(codes.identifiers, boundary)) return false;
@@ -103,6 +111,7 @@ const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContex
   if (run === undefined) return true;
   if (codes.calendar.has(run.start)) return false;
   if (boundary.kind === "before-digit" && isSpacedLocationPart(sentence.text, run, sentence.tokens, sentence.span.start, context.floors)) return false;
+  if (isFieldSeparator(sentence.text, boundary, sentence.tokens, sentence.span.start)) return false;
   return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context);
 };
 
@@ -135,9 +144,9 @@ const findingAt = (entry: Located, values: Finding["values"], variant?: string):
   values: { ...values, offset: entry.sentence.span.start + entry.offset },
 });
 
-/** 一つの種類の境目の指摘。少ないほうを 1 箇所ずつか、書き方が二通りあれば 1 件で（spacing-minority.ts）。 */
+/** 一つの種類の境目の指摘。少ないほうを 1 箇所ずつか、書き方が二通りあれば 1 件で（spacing-minority.ts）。同数ならどちらの側にも立たない。 */
 const findingsOf = (kind: SpacingKind, ofKind: readonly Located[], limit: number): Finding[] => {
-  const report = minorityReport(ofKind, limit);
+  const report = withoutSideOnTie(minorityReport(ofKind, limit), ofKind);
   if (report === undefined) return [];
   if (report.mode === "mixed") {
     const { first, odd, spaced, touching } = report;

package/src/detectors/per-unit-words.ts

@@ -0,0 +1,24 @@
+import type { ProseDocument, StructureNode } from "../plugin.ts";
+import { withPerUnits, type PerUnitMark, type PerUnitTemplate, type PerUnitWords } from "../facts/per-unit.ts";
+import { factValues, type FactValue } from "../facts/fact-values.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+
+const marksOf = (doc: ProseDocument, id: string): PerUnitMark[] =>
+  (doc.lexicons[id] ?? []).map((entry): PerUnitMark => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+/** 何あたりかの語: 決まった印（per-unit-mark）、型（fact-per-unit）、単位の語（rate-unit）、読まない百分率（percent-unit）、単価の列の見出し（unit-price-column）。 */
+const perUnitWordsOf = (doc: ProseDocument): PerUnitWords => ({
+  marks: marksOf(doc, "per-unit-mark"),
+  templates: (doc.lexicons["fact-per-unit"] ?? []).map((entry): PerUnitTemplate => ({ pattern: entry.pattern, position: entry.position ?? "before" })),
+  units: marksOf(doc, "rate-unit"),
+  percentUnits: (doc.lexicons["percent-unit"] ?? []).map((entry) => entry.pattern),
+  priceHeadings: (doc.lexicons["unit-price-column"] ?? []).map((entry) =>
+    entry.group === undefined ? { pattern: entry.pattern } : { pattern: entry.pattern, group: entry.group },
+  ),
+});
+
+/** 文書の値に、何あたりか（1kmあたり15円 の km）を付ける。 */
+export const perUnitsOf = <T extends FactValue>(doc: ProseDocument, values: readonly T[]): T[] => withPerUnits(doc.source, values, perUnitWordsOf(doc));
+
+/** 木の数量と日付と固有名詞（factValues）に、何あたりかを付けたもの。 */
+export const perUnitValues = (doc: ProseDocument, tree: StructureNode): FactValue[] => perUnitsOf(doc, factValues(tree, doc.source, nameSpans(doc)));

package/src/detectors/period-multiple-mismatch.ts

@@ -4,11 +4,9 @@
 // number-word (digit), and a range of counts is joined by range-connector or amount-range-word.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { periodMultipleMismatches, type PeriodMultipleWords } from "../structure/period-multiple.ts";
-import type { StatedAmount } from "../structure/stated-multiple.ts";
-import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
-import { amountsIn, formsOf } from "./currency-notation.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
+import { statedAmountsOf } from "./stated-amounts.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
@@ -27,23 +25,9 @@ const wordsOf = (doc: ProseDocument): PeriodMultipleWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
-  const scales = scaleWordsOf(doc);
-  return amountsIn(
-    text,
-    formsOf(doc),
-    scales.map((scale) => scale.word),
-  ).flatMap((amount) => {
-    const read = scaledAmountOf(text, amount, scales);
-    return read === undefined
-      ? []
-      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
-  });
-};
-
 export const periodMultipleMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  return periodMultipleMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+  return periodMultipleMismatches(text, statedAmountsOf(text, doc), wordsOf(doc)).map((issue) => ({
     rule: "period-multiple-mismatch",
     severity: "warning",
     line: 0,

package/src/detectors/reference-number-variant.ts

@@ -1,13 +1,14 @@
 // reference-number-variant: a document's own reference number written with two neighbouring characters swapped somewhere
 // else in the document, after a label of the same kind (reference-numbers.ts), or with no label where only one labelled
-// code swaps to it (unlabelled-references.ts); and the document's one vehicle plate written
+// code swaps to it (unlabelled-references.ts), or as the one code a product document is about (subject-codes.ts); and the document's one vehicle plate written
 // once with one character of its serial changed (vehicle-plates.ts).
-import { labelledReferenceNumbers, referenceVariants, type ReferenceNumber } from "../reference-numbers.ts";
+import { labelledReferenceNumbers, referenceVariants, type ReferenceNumber, type ReferenceVariant } from "../reference-numbers.ts";
 import { labelledPlates, plateVariants } from "../vehicle-plates.ts";
-import { tableCodes, tableLabelledCodes, unlabelledVariants } from "../unlabelled-references.ts";
+import { isCodeWith, tableCodes, tableLabelledCodes, unlabelledVariants } from "../unlabelled-references.ts";
+import { isSubjectCode, MIN_SUBJECT_DIGITS, subjectCodeVariants } from "../subject-codes.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAt } from "./structure-tree.ts";
-import type { Detector, Finding, OptionValue } from "../plugin.ts";
+import type { Detector, Finding, OptionValue, ProseDocument } from "../plugin.ts";
 
 const PLATE_SHAPES = "vehicle-plate";
 const SUBSTITUTED = "substituted";
@@ -25,6 +26,18 @@ const finding = (number: ReferenceNumber, other: ReferenceNumber, source: string
 /** Kinds a document lists many of (item codes): two labelled ones are two things, so only a code with no label is compared with them. */
 const listedKindsOf = (value: OptionValue | undefined): readonly string[] => (typeof value === "object" ? value : []);
 
+const TITLE_DEPTH = 1;
+
+/** The title as the source writes it, where it starts: the prose masks a heading's line. */
+const titleOf = (doc: ProseDocument): { start: number; text: string } | undefined => {
+  const title = doc.markup?.headings.find((heading) => heading.depth === TITLE_DEPTH);
+  return title === undefined ? undefined : { start: title.start, text: doc.source.slice(title.start, title.end) };
+};
+
+/** One finding per place, the first reading kept: a code may be read both as an unlabelled item code and as the document's own. */
+const firstAtEachOffset = (variants: readonly ReferenceVariant[]): ReferenceVariant[] =>
+  variants.filter((variant, index) => variants.findIndex((other) => other.number.offset === variant.number.offset) === index);
+
 export const referenceNumberVariant: Detector = (doc, options): Finding[] => {
   const labels = options.lexicon ?? [];
   if (labels.length === 0) return [];
@@ -36,9 +49,18 @@ export const referenceNumberVariant: Detector = (doc, options): Finding[] => {
   const listed = new Set(listedKindsOf(options.settings?.["listed_kinds"]));
   const withTables = proseAndTablesOf(doc);
   const labelled = [...numbers, ...tableLabelledCodes(withTables, labels)];
+  const subjectCodes = subjectCodeVariants({
+    prose: text,
+    title: titleOf(doc),
+    labels,
+    listed,
+    tabled: tableLabelledCodes(withTables, labels, isSubjectCode),
+    known: tableCodes(withTables, isCodeWith(MIN_SUBJECT_DIGITS)),
+  });
+  const unlabelled = firstAtEachOffset([...unlabelledVariants(text, labelled, tableCodes(withTables)), ...subjectCodes]);
   return [
     ...referenceVariants(numbers.filter((number) => !listed.has(number.label))).map(({ number, other }) => finding(number, other, doc.source)),
-    ...unlabelledVariants(text, labelled, tableCodes(withTables)).map(({ number, other }) => finding(number, other, doc.source)),
+    ...unlabelled.map(({ number, other }) => finding(number, other, doc.source)),
     ...plateVariants(plates).map(({ number, other }) => finding(number, other, doc.source, SUBSTITUTED)),
   ].toSorted((a, b) => Number(a.values["offset"]) - Number(b.values["offset"]));
 };

package/src/detectors/registry/condition-toki.ts

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

package/src/detectors/registry/formula-amount.ts

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

package/src/detectors/rent-multiple-mismatch.ts

@@ -4,11 +4,9 @@
 // range of rent is joined by range-connector or amount-range-word.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { rentMultipleMismatches, type RentMultipleWords } from "../structure/rent-multiple.ts";
-import type { StatedAmount } from "../structure/stated-multiple.ts";
-import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
-import { amountsIn, formsOf } from "./currency-notation.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
+import { statedAmountsOf } from "./stated-amounts.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
@@ -30,23 +28,9 @@ const wordsOf = (doc: ProseDocument): RentMultipleWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
-  const scales = scaleWordsOf(doc);
-  return amountsIn(
-    text,
-    formsOf(doc),
-    scales.map((scale) => scale.word),
-  ).flatMap((amount) => {
-    const read = scaledAmountOf(text, amount, scales);
-    return read === undefined
-      ? []
-      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
-  });
-};
-
 export const rentMultipleMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
-  return rentMultipleMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+  return rentMultipleMismatches(text, statedAmountsOf(text, doc), wordsOf(doc)).map((issue) => ({
     rule: "rent-multiple-mismatch",
     severity: "warning",
     line: 0,

package/src/detectors/row-sentence-amounts.ts

@@ -4,15 +4,8 @@ import { factValues, type FactValue } from "../facts/fact-values.ts";
 import { cellsOf, tablesOf } from "../facts/table-facts.ts";
 import { scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
 import { withoutEdgeMarks } from "../facts/trim-marks.ts";
-import {
-  periodOf,
-  rowSentenceConflicts,
-  type Amount,
-  type AmountRow,
-  type PeriodMark,
-  type SubjectSentence,
-  type SubjectWords,
-} from "../facts/row-sentence-amounts.ts";
+import { rowSentenceConflicts, type Amount, type AmountRow, type SubjectSentence, type SubjectWords } from "../facts/row-sentence-amounts.ts";
+import { perUnitsOf } from "./per-unit-words.ts";
 import { linesOf, type Line } from "../structure/lines.ts";
 import { quoteAt } from "./structure-tree.ts";
 
@@ -57,19 +50,11 @@ const subjectWordsOf = (doc: ProseDocument): SubjectWords => ({
   conditions: patternsOf(doc, "fact-amount-condition"),
 });
 
-const periodMarksOf = (doc: ProseDocument): PeriodMark[] =>
-  (doc.lexicons["per-unit-mark"] ?? []).map((entry): PeriodMark => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
-
-/** 金額: 通貨の語彙表の印を単位に書いた数量。前後に期間あたりの印があれば、その期間も。 */
+/** 金額: 通貨の語彙表の印を単位に書いた数量。何あたりの金額（日額、1kmあたり）は、その単位も。 */
 const amountsOf = (doc: ProseDocument, tree: StructureNode): Amount[] => {
   const currencies = new Set(patternsOf(doc, "currency-notation").map((pattern) => pattern.normalize("NFKC")));
-  const marks = periodMarksOf(doc);
-  return factValues(tree, doc.source, nameSpans(doc))
-    .filter((value) => value.kind === "quantity" && currencies.has(value.unit))
-    .map((value): Amount => {
-      const period = periodOf(doc.source, value, marks);
-      return period === undefined ? value : { ...value, period };
-    });
+  const amounts = factValues(tree, doc.source, nameSpans(doc)).filter((value) => value.kind === "quantity" && currencies.has(value.unit));
+  return perUnitsOf(doc, amounts);
 };
 
 /** 表の行の金額と、その行の見出しを主語にした文の金額の食い違い。名前付きの値として読めた文の値は、ほかの読みが比べる。 */

package/src/detectors/stated-amounts.ts

@@ -0,0 +1,20 @@
+// The amounts a document states, as the multiple and total checks read them: currency-notation's written amounts, each
+// read with amount-multiplier's words of scale (1億2,000万円 is one amount), the ones that cannot be read left out.
+import type { ProseDocument } from "../plugin.ts";
+import type { StatedAmount } from "../structure/stated-multiple.ts";
+import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+
+export const statedAmountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
+  const scales = scaleWordsOf(doc);
+  return amountsIn(
+    text,
+    formsOf(doc),
+    scales.map((scale) => scale.word),
+  ).flatMap((amount) => {
+    const read = scaledAmountOf(text, amount, scales);
+    return read === undefined
+      ? []
+      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
+  });
+};

package/src/detectors/step-time-sum.ts

@@ -3,6 +3,7 @@
 import { stepTimeSlip, type StepTimeWords } from "../structure/step-times.ts";
 import type { Mark } from "../structure/time-marks.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 
 const SECONDS_PER_HOUR = 3600;
@@ -35,7 +36,7 @@ const wordsOf = (doc: ProseDocument): StepTimeWords => {
 };
 
 export const stepTimeSumMismatch: Detector = (doc): Finding[] => {
-  const slip = stepTimeSlip(doc.source, wordsOf(doc));
+  const slip = stepTimeSlip(withoutCodeBlocks(doc.source), wordsOf(doc));
   if (slip === undefined) return [];
   return [
     {

package/src/detectors/structure-tree.ts

@@ -14,6 +14,7 @@ import { withCompoundHours } from "../structure/compound-hours.ts";
 import { timeLengths } from "../derived/time-lengths.ts";
 import { measureUnitsOf } from "../facts/measure-units.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
+import { isStartEndRange, startEndWordsOf } from "../structure/start-end-range.ts";
 import { afterLabel } from "../structure/stated-period.ts";
 import { afterSpanLabel } from "../structure/span-label.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
@@ -264,6 +265,9 @@ const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["struct
     breakdowns: patternsOf(doc, "breakdown-phrase"),
     discounts: patternsOf(doc, "discount-word"),
     joiners: patternsOf(doc, "breakdown-gap-joiner"),
+    leads: patternsOf(doc, "total-breakdown-lead"),
+    partials: patternsOf(doc, "breakdown-partial-word"),
+    backReferences: patternsOf(doc, "total-back-reference"),
   };
   const prose = proseTotalMismatches(
     doc.source,
@@ -310,11 +314,12 @@ const labelledAt =
     return after !== undefined && offset >= lineStart + after;
   };
 
-/** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
+/** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer、range-start-end）から取る。 */
 export const dateRangeReversed: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const dates = datedSpans(doc.structure);
-  return reversedRanges(doc.source, dates, rangeWordsOf(doc), labelledAt(doc))
+  const startEnd = startEndWordsOf(doc.lexicons["range-start-end"] ?? [], patternsOf(doc, "weekday"));
+  return reversedRanges(doc.source, dates, rangeWordsOf(doc), labelledAt(doc), (start, end) => isStartEndRange(doc.source, start, end, startEnd))
     .filter((issue) => {
       const start = dateAt(dates, issue.offset);
       return !quotedDates(doc, dates[start], dates[start + 1]);

package/src/detectors/team.ts

@@ -2,7 +2,8 @@ import { proseText } from "../measure.ts";
 import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
 import { nameSpans } from "../team-names.ts";
-import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+import { conjugatedSpans } from "./conjugated-entry.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
 /**
  * チームの言葉。社内でしか通じない語を、チームが chaff.yaml に自分で並べる。
@@ -12,19 +13,24 @@ import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "..
  */
 /**
  * 表層でも原形でも当てる。利用者は辞書形で書く（「握る」）が、本文は活用している（「握った」）。
+ * 複合動詞（「巻き取る」）は語に割れるので、語の並びで原形に照らす（「巻き取ります」）。
  * 品詞解析があれば原形で当たり、無くても表層で当たる。要求はしない。
  */
-const matches = (sentence: Sentence, word: string): boolean => {
+const matches = (sentence: Sentence, entry: LexiconEntry): boolean => {
   // 大文字小文字は区別しない。英語の文頭の「Circle back」も「circle back」として当てる。
-  const wanted = word.toLowerCase();
-  return sentence.text.toLowerCase().includes(wanted) || (sentence.tokens ?? []).some((token) => token.lemma?.toLowerCase() === wanted);
+  const wanted = entry.pattern.toLowerCase();
+  return (
+    sentence.text.toLowerCase().includes(wanted) ||
+    (sentence.tokens ?? []).some((token) => token.lemma?.toLowerCase() === wanted) ||
+    conjugatedSpans(sentence, entry).length > 0
+  );
 };
 
 export const internalJargon: Detector = (doc, options): Finding[] => {
-  const words = (options.lexicon ?? []).map((entry) => entry.pattern);
-  if (words.length === 0) return [];
+  const entries = options.lexicon ?? [];
+  if (entries.length === 0) return [];
   const hits = doc.sentences.flatMap((sentence) => {
-    const matched = words.find((word) => matches(sentence, word));
+    const matched = entries.find((entry) => matches(sentence, entry))?.pattern;
     return matched === undefined ? [] : [{ sentence, matched }];
   });
   if (hits.length < options.limit) return [];

package/src/detectors/time-order.ts

@@ -11,6 +11,7 @@ import { reversedTimeRanges } from "../structure/time-range.ts";
 import { cellMinutes, reversedShiftRows, showsOvernightWork } from "../structure/shift-times.ts";
 import { pairedTimesOutOfOrder } from "../structure/labelled-time-order.ts";
 import { quoteAt, rangeWordsOf } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 
 // 一日の予定の時刻の順番と、語の決まった二つの時刻の順番（time-order）、発より前の着（arrival-before-departure）、移動の時間より短い乗り継ぎ（connection-time-short）。時刻は compare/clock-time.ts が読み、
 // 発着・翌日・時間帯の語は言語パッケージの語彙表（leg-mark、leg-column、day-shift-mark、time-zone、local-time-mark）から取る。
@@ -43,11 +44,12 @@ const variantOf = (issue: StructureIssue, variant: string | undefined): string |
   return "end_label" in issue.values ? "columns" : undefined;
 };
 
-/** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。 */
+/** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。コードブロックは例なので覆う。 */
 const detectorOf =
   (rule: string, find: Finder, variant?: string): Detector =>
-  (doc): Finding[] =>
-    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => {
+  (doc): Finding[] => {
+    const source = withoutCodeBlocks(doc.source);
+    return find(source, timesOf(source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => {
       const named = variantOf(issue, variant);
       return {
         rule,
@@ -59,6 +61,7 @@ const detectorOf =
         ...(named === undefined ? {} : { variant: named }),
       };
     });
+  };
 
 const timeOrderInList: Detector = detectorOf("time-order", timeOrderBreaks);
 /** 語の決まった二つの時刻（開場と開演）。語は語彙表 timed-pair-label から取る。 */

package/src/detectors/unknown-word.ts

@@ -1,5 +1,7 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { isKnownWord, isSplitWord, suggestionFor, wordsToCheck, type CheckedWord, type Speller } from "../spelling.ts";
+import { parse } from "../markdown-read.ts";
+import { eachPreOrder } from "../tree-walk.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 /** これより短い語は見ない。短い語は一字違いの語が多すぎて言い直しが決まらず（tost は test か toast か）、略した語（impl）も多い。 */
@@ -24,14 +26,30 @@ const usedOnce = (words: readonly CheckedWord[]): CheckedWord[] => {
   return words.filter(({ word }) => counts.get(word) === 1);
 };
 
+const LETTERS = /\p{L}+/gu;
+
+/** 文書がコード（コードの区画と `…`）に書いた語。コードに書いた名前（`tidyq check` の tidyq）は、地の文でも打ち間違いではない。 */
+export const codeWordsOf = (source: string): Set<string> => {
+  const words = new Set<string>();
+  eachPreOrder(parse(source), (node) => {
+    if (node.type === "code" || node.type === "inlineCode")
+      (node.value ?? "")
+        .toLowerCase()
+        .match(LETTERS)
+        ?.forEach((word) => words.add(word));
+  });
+  return words;
+};
+
 /**
  * 辞書に無い英語の語で、一字違いの辞書の語があるもの（recieve → receive）。辞書は adapter が持ち、無い言語では動かない。
- * 大文字を含む語（固有名詞・略語）、コード・URL の中、頭の字を分けた語の残り、二度以上使う語、言い直しの無い語は言わない。
+ * 大文字を含む語（固有名詞・略語）、コード・URL の中、頭の字を分けた語の残り、二度以上使う語、言い直しの無い語、
+ * 文書がコードにも書いた語は言わない。
  */
 export const unknownWord: Detector = (doc): Finding[] => {
   if (doc.dictionary === undefined) return [];
   const speller = spellerOf(doc, doc.dictionary());
-  const known = new Set(patternsOf(doc, "known-misspelling"));
+  const known = new Set([...patternsOf(doc, "known-misspelling"), ...codeWordsOf(doc.source)]);
   const words = wordsToCheck(doc.prose ?? doc.source, MIN_LENGTH, MAX_LENGTH).filter(({ offset }) => !isSplitWord(doc.source, offset));
   const used = new Set(words.map(({ word }) => word).filter((word) => isKnownWord(word, speller)));
   return usedOnce(words).flatMap(({ offset, word }) => {

package/src/detectors/use-interval.ts

@@ -4,6 +4,7 @@ import { paragraphsOf } from "../derived/period-counts.ts";
 import { timeLengths, type TimeLength } from "../derived/time-lengths.ts";
 import { limitWordsOf, marksOf, periodCountWordsOf } from "./use-count-words.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 
 // 使う間隔の下限と期間あたりの回数の上限が両立しない、または表の回数と合わない（interval-count-mismatch）。
 // 語は use-count-word と use-interval-word、長さの単位は unit-time から取る。
@@ -14,8 +15,8 @@ const SECONDS_PER_MINUTE = 60;
 const patternsOf = (doc: ProseDocument, lexicon: string, weight?: number): string[] =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => weight === undefined || entry.weight === weight).map((entry) => entry.pattern);
 
-const lengthsOf = (doc: ProseDocument): TimeLength[] =>
-  timeLengths(doc.source, {
+const lengthsOf = (doc: ProseDocument, text: string): TimeLength[] =>
+  timeLengths(text, {
     hourUnits: patternsOf(doc, "unit-time", SECONDS_PER_HOUR),
     minuteUnits: patternsOf(doc, "unit-time", SECONDS_PER_MINUTE),
     halves: patternsOf(doc, "length-half"),
@@ -39,8 +40,10 @@ const valuesOf = (doc: ProseDocument, mismatch: IntervalMismatch): Record<string
     ? { count: written(doc, mismatch.count), interval: written(doc, mismatch.interval), needed: mismatch.neededHours, hours: mismatch.count.hours }
     : { count: written(doc, mismatch.count), column: mismatch.column, table: mismatch.tableCount };
 
-export const intervalCountMismatch: Detector = (doc): Finding[] =>
-  intervalCountMismatches(doc.source, paragraphsOf(doc.source), lengthsOf(doc), wordsOf(doc)).map((mismatch) => ({
+/** コードブロックの中の用法は例なので、覆って読む。 */
+export const intervalCountMismatch: Detector = (doc): Finding[] => {
+  const text = withoutCodeBlocks(doc.source);
+  return intervalCountMismatches(text, paragraphsOf(text), lengthsOf(doc, text), wordsOf(doc)).map((mismatch) => ({
     rule: "interval-count-mismatch",
     severity: "warning",
     line: 0,
@@ -49,3 +52,4 @@ export const intervalCountMismatch: Detector = (doc): Finding[] =>
     values: { ...valuesOf(doc, mismatch), offset: mismatch.count.start },
     ...(mismatch.kind === "table" ? { variant: "table" } : {}),
   }));
+};

package/src/detectors/use-maximum.ts

@@ -3,6 +3,7 @@ import { exceededMaxima } from "../derived/use-maximum.ts";
 import { paragraphsOf } from "../derived/period-counts.ts";
 import { limitWordsOf, marksOf, periodCountWordsOf } from "./use-count-words.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 import { isMoneySpan, type CurrencyMark } from "../derived/money-span.ts";
 
 // 1回の量 × 期間あたりの回数が、その期間の上限を超える（product-exceeds-maximum）。語は use-count-word と use-amount-word から取る。
@@ -19,7 +20,8 @@ export const productExceedsMaximum: Detector = (doc): Finding[] => {
   const marks = currencyMarksOf(doc);
   const unitOf = (span: Span): string => written(doc, span).replace(LEADING_NUMBER, "");
   const isMoney = (span: Span): boolean => isMoneySpan(doc.source, span, unitOf(span), marks);
-  const amounts = exceededMaxima(doc.source, paragraphsOf(doc.source), words).filter((exceeded) => !isMoney(exceeded.maximum) && !isMoney(exceeded.perUse));
+  const text = withoutCodeBlocks(doc.source);
+  const amounts = exceededMaxima(text, paragraphsOf(text), words).filter((exceeded) => !isMoney(exceeded.maximum) && !isMoney(exceeded.perUse));
   return amounts.map((exceeded) => ({
     rule: "product-exceeds-maximum",
     severity: "warning",

package/src/eval.ts

@@ -46,12 +46,12 @@ const candidates = (rule: RuleDefinition, current: number): number[] => {
   return [...new Set([...fromLevels, ...scaled, current])].toSorted((left, right) => left - right);
 };
 
-const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number, settings: DetectorOptions["settings"]): Point => {
+const countAt = (docs: readonly ProseDocument[], rule: RuleDefinition, limit: number, settings: DetectorOptions["settings"], genre: string): Point => {
   const detector = DETECTORS[rule.how_to_find];
   if (detector === undefined) return { limit, findings: 0, documents: 0, per10k: 0 };
   const perDoc = docs.map((doc) => {
     const lexicon = rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list];
-    return detector(doc, { limit, lexicon, where: rule.where, settings }).length;
+    return detector(doc, { limit, lexicon, where: rule.where, settings, genre }).length;
   });
   const findings = perDoc.reduce((sum, count) => sum + count, 0);
   const chars = docs.reduce((sum, doc) => sum + doc.sentences.reduce((inner, sentence) => inner + charLength(sentence), 0), 0);
@@ -111,7 +111,7 @@ export const evaluate = (
     .map((rule) => {
       const current = limits[rule.id] ?? rule.levels.normal ?? 1;
       const settings = rule.options === undefined ? undefined : optionValues(settleOptions(rule.id, rule.options, optionLayers));
-      const sweep = candidates(rule, current).map((limit) => countAt(docs, rule, limit, settings));
+      const sweep = candidates(rule, current).map((limit) => countAt(docs, rule, limit, settings, genre));
       return {
         rule: rule.id,
         name: rule.name[language] ?? rule.id,