chaffjs 0.30.0 → 0.32.0

package/src/detectors/range-words.ts

@@ -0,0 +1,17 @@
+import type { ProseDocument } from "../plugin.ts";
+import { rangeFrameOf } from "../structure/date-range.ts";
+import type { PeriodWords } from "../structure/stated-period.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** The words that read a period on a labelled line: the range signs (range-connector, range-opener, range-frame's joint), month and weekday names. */
+export const periodWordsOf = (doc: ProseDocument, labels: readonly string[]): PeriodWords => ({
+  labels,
+  connectors: [
+    ...patternsOf(doc, "range-connector"),
+    ...patternsOf(doc, "range-opener"),
+    ...patternsOf(doc, "range-frame").flatMap((pattern) => rangeFrameOf(pattern)?.joint ?? []),
+  ],
+  months: patternsOf(doc, "month-name"),
+  weekdays: patternsOf(doc, "weekday"),
+});

package/src/detectors/ratio-mismatch.ts

@@ -0,0 +1,116 @@
+// ratio-mismatch: the reading half. Reads the tables (each row's label and cells) and the sentences (the words of lexicons
+// ratio-label and ratio-term, and the structure tree's quantities in a currency or a percent unit) and leaves the deciding
+// to structure/ratio.ts.
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAt } from "./structure-tree.ts";
+import {
+  proseValues,
+  sentenceRatioMismatch,
+  tableRatioMismatches,
+  type AmountWords,
+  proseQuantitiesOf,
+  type LabelHit,
+  type RatioIssue,
+  type RatioWords,
+  type TableRow,
+} from "../structure/ratio.ts";
+
+const RULE = "ratio-mismatch";
+const LATIN = /^[A-Za-z]/u;
+/** A ratio label's group names the two terms it divides: "operating-profit/sales". */
+const GROUP_SEPARATOR = "/";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): RatioWords => ({
+  labels: (doc.lexicons["ratio-label"] ?? []).flatMap((entry) => {
+    const [numerator, denominator, ...rest] = (entry.group ?? "").split(GROUP_SEPARATOR);
+    return numerator === undefined || denominator === undefined || rest.length > 0 ? [] : [{ pattern: entry.pattern, numerator, denominator }];
+  }),
+  terms: (doc.lexicons["ratio-term"] ?? []).flatMap((entry) => (entry.group === undefined ? [] : [{ pattern: entry.pattern, term: entry.group }])),
+  percentUnits: patternsOf(doc, "percent-unit"),
+});
+
+const currencyMarks = (doc: ProseDocument, position: "before" | "after"): string[] =>
+  (doc.lexicons["currency-notation"] ?? []).filter((entry) => entry.position === position).map((entry) => entry.pattern);
+
+const amountWordsOf = (doc: ProseDocument, percentUnits: readonly string[]): AmountWords => ({
+  before: currencyMarks(doc, "before"),
+  after: currencyMarks(doc, "after"),
+  multipliers: patternsOf(doc, "amount-multiplier"),
+  percentUnits,
+});
+
+/** A table line read as its label (the first cell) and the cells after it, each without its edge marks. */
+export const tableRowOf = (row: Line): TableRow[] => {
+  const [first, ...rest] = cellsOf(row);
+  if (first === undefined) return [];
+  const cells = rest.map((cell) => {
+    const text = withoutEdgeMarks(cell.text);
+    return { start: cell.start + Math.max(0, cell.text.indexOf(text)), text };
+  });
+  return [{ label: withoutEdgeMarks(first.text), cells }];
+};
+
+const tableRowsOf = (source: string): TableRow[][] => tablesOf(linesOf(source)).map((table) => table.rows.flatMap(tableRowOf));
+
+/** A kanji or katakana next to a word written in them makes it part of a longer word (営業利益率 in 調整後営業利益率). */
+const CJK_LETTER = /[\p{sc=Han}\p{sc=Katakana}ー]/u;
+
+/** Where a word stands in the text: a Latin word as a whole word in any case, any other word not inside a longer one. */
+const spansOf = (text: string, offset: number, word: string): Span[] => {
+  const latin = LATIN.test(word);
+  const pattern = latin ? new RegExp(`\\b${escapeRegExp(word)}\\b`, "giu") : new RegExp(escapeRegExp(word), "gu");
+  return [...text.matchAll(pattern)]
+    .filter((match) => latin || !(CJK_LETTER.test(text.charAt(match.index - 1)) || CJK_LETTER.test(text.charAt(match.index + match[0].length))))
+    .map((match) => ({ start: offset + match.index, end: offset + match.index + match[0].length }));
+};
+
+/** A word inside a longer one is not a word of its own (営業利益 in 営業利益率, sales in net sales). */
+const longestHits = (hits: readonly LabelHit[]): LabelHit[] =>
+  hits.filter(
+    (hit) => !hits.some((other) => other !== hit && other.start <= hit.start && hit.end <= other.end && other.end - other.start > hit.end - hit.start),
+  );
+
+const hitsIn = (text: string, offset: number, words: RatioWords): LabelHit[] => {
+  const labels = words.labels.flatMap((label) => spansOf(text, offset, label.pattern).map((at) => ({ ...at, label })));
+  const terms = words.terms.flatMap((term) => spansOf(text, offset, term.pattern).map((at) => ({ ...at, term: term.term })));
+  return longestHits([...labels, ...terms]);
+};
+
+const proseIssues = (doc: ProseDocument, words: RatioWords): RatioIssue[] => {
+  const named = doc.sentences.flatMap((sentence) => {
+    const text = doc.source.slice(sentence.span.start, sentence.span.end);
+    const hits = hitsIn(text, sentence.span.start, words);
+    return hits.some((hit) => "label" in hit) ? [{ span: sentence.span, text, hits }] : [];
+  });
+  if (named.length === 0) return [];
+  const amountWords = amountWordsOf(doc, words.percentUnits);
+  const quantities = proseQuantitiesOf(doc.structure);
+  return named.flatMap(({ span, text, hits }) => {
+    const issue = sentenceRatioMismatch({ hits, end: span.end, ...proseValues(text, span.start, quantities, amountWords) });
+    return issue === undefined ? [] : [issue];
+  });
+};
+
+export const ratioMismatch: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.labels.length === 0) return [];
+  const tables = tableRowsOf(proseAndTablesOf(doc)).flatMap((rows) => tableRatioMismatches(rows, words));
+  const prose = proseIssues(doc, words).filter((issue) => !tables.some((table) => table.offset === issue.offset));
+  return [...tables, ...prose]
+    .toSorted((left, right) => left.offset - right.offset)
+    .map((issue) => ({
+      rule: RULE,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+};

package/src/detectors/readable-dates.ts

@@ -0,0 +1,36 @@
+import type { ProseDocument } from "../plugin.ts";
+import { dayOrderOf, readableDate, type DateWords } from "../derived/readable-date.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+
+const MONTHS_IN_YEAR = 12;
+
+const wordsOf = (doc: ProseDocument): DateWords => {
+  const monthWords = (doc.lexicons["month-name"] ?? []).map((entry) => entry.pattern);
+  const written =
+    doc.structure === undefined
+      ? []
+      : inDocumentOrder(doc.structure).flatMap((node) => (node.kind === "date" ? [doc.source.slice(node.span.start, node.span.end)] : []));
+  return { language: doc.language, months: monthWords.slice(0, MONTHS_IN_YEAR), order: dayOrderOf(written, monthWords) };
+};
+
+const wordsByDocument = new WeakMap<ProseDocument, DateWords>();
+
+/**
+ * A date value (2026-06-30) as a message writes it, in the document's language and its own day order. The month names are
+ * the language's month-name lexicon (January first). The document is read once, on the first date a message needs.
+ */
+export const readableDates =
+  (doc: ProseDocument) =>
+  (value: string): string => {
+    const words = wordsByDocument.get(doc) ?? wordsOf(doc);
+    wordsByDocument.set(doc, words);
+    return readableDate(value, words);
+  };
+
+/** The named values written as readable dates; the other values as they are. */
+export const withReadableDates = (
+  values: Readonly<Record<string, string | number>>,
+  keys: readonly string[],
+  readable: (value: string) => string,
+): Record<string, string | number> =>
+  Object.fromEntries(Object.entries(values).map(([key, value]) => [key, keys.includes(key) && typeof value === "string" ? readable(value) : value]));

package/src/detectors/reference-flag.ts

@@ -0,0 +1,36 @@
+// reference-flag-mismatch: the reading half (structure/reference-flags.ts). The column headings are lab-result-column's and
+// reference-column-heading's, the flags reference-flag's, and a range is read with range-band-word and reference-bound-mark.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { referenceFlagSlips, type FlagMeaning, type ReferenceWords } from "../structure/reference-flags.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { labColumnWordsOf } from "./lab-columns.ts";
+import { bandWordsOf } from "./range-band.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const isMeaning = (group: string | undefined): group is FlagMeaning => group === "high" || group === "low" || group === "normal" || group === "outside";
+
+const wordsOf = (doc: ProseDocument): ReferenceWords => {
+  const boundWords = [...(doc.lexicons["range-band-word"] ?? []), ...(doc.lexicons["reference-bound-mark"] ?? [])];
+  const band = bandWordsOf({ ...doc.lexicons, "range-band-word": boundWords });
+  return {
+    headings: labColumnWordsOf(doc, "reference-column-heading"),
+    flags: (doc.lexicons["reference-flag"] ?? []).flatMap((entry) => (isMeaning(entry.group) ? [{ pattern: entry.pattern, meaning: entry.group }] : [])),
+    band: { ...band, units: [], headings: [] },
+  };
+};
+
+export const referenceFlag: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return referenceFlagSlips(text, wordsOf(doc)).map((slip) => {
+    const offset = slip.flag.start + (slip.flag.text.length - slip.flag.text.trimStart().length);
+    return {
+      rule: "reference-flag-mismatch",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(text, offset),
+      ...(slip.kind === "inside" ? {} : { variant: slip.kind }),
+      values: { item: slip.item, value: slip.value, range: slip.range, flag: slip.flag.text.trim(), offset },
+    };
+  });
+};

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

@@ -0,0 +1,25 @@
+// reference-number-repeated: the reading half. Reads the document's Markdown tables and the lexicon reference-column, and
+// leaves the deciding to structure/reference-number-repeated.ts.
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { lineNumberAt, linesOf } from "../structure/lines.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { repeatedReferences } from "../structure/reference-number-repeated.ts";
+
+const RULE = "reference-number-repeated";
+
+export const referenceNumberRepeated: Detector = (doc): Finding[] => {
+  const words = (doc.lexicons["reference-column"] ?? []).map((entry) => entry.pattern);
+  if (words.length === 0) return [];
+  const tables = tablesOf(linesOf(proseAndTablesOf(doc))).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+  const sourceLines = linesOf(doc.source);
+  return repeatedReferences(tables, words).map((repeat) => ({
+    rule: RULE,
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, repeat.offset),
+    values: { number: repeat.number, heading: repeat.heading, firstLine: lineNumberAt(sourceLines, repeat.firstOffset) ?? 0, offset: repeat.offset },
+  }));
+};

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

@@ -0,0 +1,44 @@
+// 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
+// once with one character of its serial changed (vehicle-plates.ts).
+import { labelledReferenceNumbers, referenceVariants, type ReferenceNumber } from "../reference-numbers.ts";
+import { labelledPlates, plateVariants } from "../vehicle-plates.ts";
+import { tableCodes, tableLabelledCodes, unlabelledVariants } from "../unlabelled-references.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, OptionValue } from "../plugin.ts";
+
+const PLATE_SHAPES = "vehicle-plate";
+const SUBSTITUTED = "substituted";
+
+const finding = (number: ReferenceNumber, other: ReferenceNumber, source: string, variant?: string): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: quoteAt(source, number.offset),
+  values: { written: number.written, other: other.written, offset: number.offset },
+  ...(variant === undefined ? {} : { variant }),
+});
+
+/** 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 : []);
+
+export const referenceNumberVariant: Detector = (doc, options): Finding[] => {
+  const labels = options.lexicon ?? [];
+  if (labels.length === 0) return [];
+  const text = doc.prose ?? doc.source;
+  const plates = labelledPlates(text, labels, doc.lexicons[PLATE_SHAPES] ?? []);
+  const inPlate = (number: ReferenceNumber): boolean =>
+    plates.some((plate) => number.offset >= plate.offset && number.offset < plate.offset + plate.written.length);
+  const numbers = [...labelledReferenceNumbers(text, labels).filter((number) => !inPlate(number)), ...plates];
+  const listed = new Set(listedKindsOf(options.settings?.["listed_kinds"]));
+  const withTables = proseAndTablesOf(doc);
+  const labelled = [...numbers, ...tableLabelledCodes(withTables, labels)];
+  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)),
+    ...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/reference-unit.ts

@@ -0,0 +1,24 @@
+// reference-unit-mismatch: the reading half. The result, reference range and unit columns are found by the language's
+// lab-result-column and reference-unit-column lexicons and the units read with reference-unit; the tables are read from the
+// prose with its tables put back, so code is not.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { referenceUnitMismatches, type UnitWord } from "../structure/reference-unit.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { labColumnWordsOf } from "./lab-columns.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const unitsOf = (doc: ProseDocument): UnitWord[] =>
+  (doc.lexicons["reference-unit"] ?? []).flatMap((entry) => (entry.group === undefined ? [] : [{ pattern: entry.pattern, unit: entry.group }]));
+
+export const referenceUnit: Detector = (doc): Finding[] => {
+  const columns = labColumnWordsOf(doc, "reference-unit-column");
+  if (columns.length === 0) return [];
+  return referenceUnitMismatches(proseAndTablesOf(doc), { units: unitsOf(doc), columns }).map((issue) => ({
+    rule: "reference-unit-mismatch",
+    severity: "error",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/registry/annual-holidays-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { annualHolidaysMismatch } from "../annual-holidays-mismatch.ts";
+
+export const detector: Detector = annualHolidaysMismatch;

package/src/detectors/registry/annual-pay-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { annualPayMismatch } from "../annual-pay-mismatch.ts";
+
+export const detector: Detector = annualPayMismatch;

package/src/detectors/registry/backorder-mismatch.ts

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

package/src/detectors/registry/bmi-mismatch.ts

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

package/src/detectors/registry/capacity-runtime-mismatch.ts

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

package/src/detectors/registry/closing-balance-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { closingBalanceMismatch } from "../closing-balance-mismatch.ts";
+
+export const detector: Detector = closingBalanceMismatch;

package/src/detectors/registry/contact-variant.ts

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

package/src/detectors/registry/count-over-capacity.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { countOverCapacity } from "../count-over-capacity.ts";
+
+export const detector: Detector = countOverCapacity;

package/src/detectors/registry/cumulative-below-current.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { cumulativeBelow } from "../cumulative-below-current.ts";
+
+export const detector: Detector = cumulativeBelow;

package/src/detectors/registry/currency-column-mix.ts

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

package/src/detectors/registry/date-stamp-order.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dateStampOrder } from "../date-stamp-order.ts";
+
+export const detector: Detector = dateStampOrder;

package/src/detectors/registry/deductible-exceeds-limit.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { deductibleExceedsLimit } from "../deductible-exceeds-limit.ts";
+
+export const detector: Detector = deductibleExceedsLimit;

package/src/detectors/registry/delivered-over-ordered.ts

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

package/src/detectors/registry/discount-rate.ts

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

package/src/detectors/registry/elapsed-years-mismatch.ts

@@ -1,4 +1,4 @@
 import type { Detector } from "../../plugin.ts";
-import { elapsedYearsMismatch } from "../derived-numbers.ts";
+import { elapsedYearsMismatch } from "../labelled-age.ts";
 
 export const detector: Detector = elapsedYearsMismatch;

package/src/detectors/registry/event-deadline.ts

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

package/src/detectors/registry/gpa-mismatch.ts

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

package/src/detectors/registry/installment-total-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { installmentTotalMismatch } from "../installment-total-mismatch.ts";
+
+export const detector: Detector = installmentTotalMismatch;

package/src/detectors/registry/interest.ts

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

package/src/detectors/registry/interval-count-mismatch.ts

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

package/src/detectors/registry/layout-code-mismatch.ts

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

package/src/detectors/registry/meter-usage.ts

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

package/src/detectors/registry/net-amount-mismatch.ts

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

package/src/detectors/registry/net-over-gross.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { netOverGrossDetector } from "../net-gross-weight.ts";
+
+export const detector: Detector = netOverGrossDetector;

package/src/detectors/registry/period-label-conflict.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { periodLabelConflict } from "../period-label-conflict.ts";
+
+export const detector: Detector = periodLabelConflict;

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

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { periodMultipleMismatch } from "../period-multiple-mismatch.ts";
+
+export const detector: Detector = periodMultipleMismatch;

package/src/detectors/registry/period-part-exceeds-whole.ts

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

package/src/detectors/registry/product-exceeds-maximum.ts

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

package/src/detectors/registry/quantity-range.ts

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

package/src/detectors/registry/range-band-mismatch.ts

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

package/src/detectors/registry/ratio-mismatch.ts

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

package/src/detectors/registry/reference-flag-mismatch.ts

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

package/src/detectors/registry/reference-number-repeated.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { referenceNumberRepeated } from "../reference-number-repeated.ts";
+
+export const detector: Detector = referenceNumberRepeated;

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

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { referenceNumberVariant } from "../reference-number-variant.ts";
+
+export const detector: Detector = referenceNumberVariant;

package/src/detectors/registry/reference-unit.ts

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

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

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { rentMultipleMismatch } from "../rent-multiple-mismatch.ts";
+
+export const detector: Detector = rentMultipleMismatch;

package/src/detectors/registry/revision-direction.ts

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

package/src/detectors/registry/running-balance.ts

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

package/src/detectors/registry/scaled-quantity-mismatch.ts

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

package/src/detectors/registry/serial-range.ts

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

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

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

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

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { stepTimeSumMismatch } from "../step-time-sum.ts";
+
+export const detector: Detector = stepTimeSumMismatch;

package/src/detectors/registry/table-unit-mix.ts

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

package/src/detectors/registry/tier-threshold.ts

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

package/src/detectors/registry/time-range-reversed.ts

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

package/src/detectors/registry/unlisted-item-used.ts

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

package/src/detectors/registry/variance-mismatch.ts

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

package/src/detectors/registry/walk-time-distance-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { walkTimeDistanceMismatch } from "../walk-time-distance-mismatch.ts";
+
+export const detector: Detector = walkTimeDistanceMismatch;

package/src/detectors/relative-dates.ts

@@ -5,6 +5,7 @@ import type { DurationUnit } from "../derived/date-arithmetic.ts";
 import { relativeMismatches, type DatedValue, type Relative } from "../derived/relative-dates.ts";
 import { quoteAt } from "./structure-tree.ts";
 import { dayWordFindings } from "./relative-day-words.ts";
+import { readableDates } from "./readable-dates.ts";
 
 /** 期間の単位の語彙表。relative-year-unit は、向きの語が付くときだけ期間になる単位（「1年前」の年）。 */
 const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
@@ -107,7 +108,7 @@ export const relativeDateMismatch: Detector = (doc): Finding[] => {
       base: doc.source.slice(mismatch.base.start, mismatch.base.end),
       relative: doc.source.slice(mismatch.relative.start, mismatch.relative.end),
       target: doc.source.slice(mismatch.target.start, mismatch.target.end),
-      expected: mismatch.expected,
+      expected: readableDates(doc)(mismatch.expected),
       offset: mismatch.target.start,
     },
   }));