chaffjs 0.31.0 → 0.32.0

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/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/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/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/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/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/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/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/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/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/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/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,
     },
   }));

package/src/detectors/relative-day-words.ts

@@ -6,6 +6,7 @@ import type { DatedValue } from "../derived/relative-dates.ts";
 import { relativeDayMismatch, type DayWord } from "../derived/relative-weekdays.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { readableDates } from "./readable-dates.ts";
 
 const FULL = /^\d{4}-\d{2}-\d{2}$/u;
 const LATIN = /^[A-Za-z]/u;
@@ -117,7 +118,7 @@ export const dayWordFindings = (doc: ProseDocument, dates: readonly DatedValue[]
             base: doc.source.slice(base.start, base.end),
             relative: doc.source.slice(word.start, word.end),
             target: doc.source.slice(target.start, target.end),
-            expected,
+            expected: readableDates(doc)(expected),
             offset: target.start,
           },
         },

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

@@ -3,7 +3,8 @@
 // the labels are rent-label and rent-multiple-label, the words rent-multiple-word, the counts number-word (digit), and a
 // range of rent is joined by range-connector or amount-range-word.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { rentMultipleMismatches, type RentAmount, type RentMultipleWords } from "../structure/rent-multiple.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";
@@ -29,7 +30,7 @@ const wordsOf = (doc: ProseDocument): RentMultipleWords => ({
   numberWords: numberWordsOf(doc),
 });
 
-const amountsOf = (text: string, doc: ProseDocument): RentAmount[] => {
+const amountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
   const scales = scaleWordsOf(doc);
   return amountsIn(
     text,

package/src/detectors/request-owner.ts

@@ -14,6 +14,7 @@ export const REQUEST_LEXICONS = {
   deadline: "request-deadline",
   owner: "request-owner",
   pointer: "request-pointer",
+  offer: "request-offer",
 } as const;
 
 type Words = Readonly<Record<keyof typeof REQUEST_LEXICONS, readonly string[]>>;
@@ -30,6 +31,7 @@ const wordsOf = (doc: ProseDocument): Words => ({
   deadline: patternsOf(doc.lexicons[REQUEST_LEXICONS.deadline]),
   owner: patternsOf(doc.lexicons[REQUEST_LEXICONS.owner]),
   pointer: patternsOf(doc.lexicons[REQUEST_LEXICONS.pointer]),
+  offer: patternsOf(doc.lexicons[REQUEST_LEXICONS.offer]),
 });
 
 /** How far apart, in characters, the action word and the request ending may be: the action must be what is requested. */
@@ -57,13 +59,14 @@ const gapBetween = (left: Place, right: Place): number => Math.max(left.start -
 
 /**
  * A request for an action: an action word next to a request ending (「確認してください」「please send」), not a condition
- * (「ご不明な点があれば…ください」 is an offer), and not a pointer to where to read more (「詳細は資料をご確認ください」).
+ * (「ご不明な点があれば…ください」 is an offer), not an open offer to take the reader's questions (「ご質問はメールでお送りください」),
+ * and not a pointer to where to read more (「詳細は資料をご確認ください」).
  * The action has to be close to the ending, or a noun like 検討会 or 履修登録 earlier in the sentence would make one.
  */
 export const isRequest = (text: string, words: Words): boolean => {
   const endings = placesOf(text, words.ending);
   const asked = placesOf(text, words.action).some((action) => endings.some((ending) => gapBetween(action, ending) <= ACTION_REACH));
-  return asked && !containsAny(text, words.condition) && !containsAny(text, words.pointer);
+  return asked && ![words.condition, words.offer, words.pointer].some((patterns) => containsAny(text, patterns));
 };
 
 const NAMED = new Set(["PROPN"]);

package/src/detectors/revision-direction.ts

@@ -0,0 +1,44 @@
+// revision-direction-mismatch: a forecast said to be revised one way whose revision table moves the other way
+// (structure/revision-direction.ts). The words are revision-direction (rise, fall; the verbs rise-verb and fall-verb, read
+// only with a word of its group forecast in their sentence) and the labels of the previous and
+// revised forecasts revision-column (previous, revised); the sections start at the headings, whose words the prose masks
+// and this puts back.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { revisionDirectionMismatches, type RevisionWords } from "../structure/revision-direction.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { proseWithCells } from "../table-cells.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): RevisionWords => ({
+  rises: patternsOf(doc, "revision-direction", "rise"),
+  falls: patternsOf(doc, "revision-direction", "fall"),
+  risesWithObject: patternsOf(doc, "revision-direction", "rise-verb"),
+  fallsWithObject: patternsOf(doc, "revision-direction", "fall-verb"),
+  objects: patternsOf(doc, "revision-direction", "forecast"),
+  previous: patternsOf(doc, "revision-column", "previous"),
+  revised: patternsOf(doc, "revision-column", "revised"),
+});
+
+export const revisionDirection: Detector = (doc): Finding[] => {
+  const headings = doc.markup?.headings ?? [];
+  const text = proseWithCells(
+    proseAndTablesOf(doc),
+    headings.map((heading) => ({ ...heading, text: doc.source.slice(heading.start, heading.end) })),
+  );
+  const input = {
+    text,
+    sectionStarts: headings.map((heading) => heading.start),
+    units: [...headings, ...doc.sentences.map((sentence) => sentence.span)],
+  };
+  return revisionDirectionMismatches(input, wordsOf(doc)).map((issue) => ({
+    rule: "revision-direction-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

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

@@ -0,0 +1,96 @@
+import type { Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+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 { linesOf, type Line } from "../structure/lines.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const LETTER = /\p{L}/u;
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const within = <T extends FactValue>(span: { start: number; end: number }, values: readonly T[]): T[] =>
+  values.filter((value) => span.start <= value.start && value.end <= span.end);
+
+/** 範囲は事実と同じ読み（fact-scope）。値の位置で決まる。位置ごとの範囲。 */
+const scopesAt = (doc: ProseDocument, tree: StructureNode, values: readonly FactValue[]): ReadonlyMap<number, string> =>
+  new Map(
+    scopedFacts(
+      values.map((value) => ({ label: "", key: "", value })),
+      tree,
+      doc.source,
+      patternsOf(doc, "summary-heading"),
+    ).map((fact) => [fact.value.start, fact.scope]),
+  );
+
+const amountRow = (row: Line, amounts: readonly Amount[], scopes: ReadonlyMap<number, string>): AmountRow[] => {
+  const [first, ...rest] = cellsOf(row);
+  if (first === undefined) return [];
+  const label = withoutEdgeMarks(first.text);
+  const inRow = rest.flatMap((cell) => within(cell, amounts));
+  const [head] = inRow;
+  if (head === undefined || !LETTER.test(label) || within(first, amounts).length > 0) return [];
+  return [{ label, scope: scopes.get(head.start) ?? "", amounts: inRow }];
+};
+
+const subjectSentences = (doc: ProseDocument, amounts: readonly Amount[], scopes: ReadonlyMap<number, string>): SubjectSentence[] =>
+  doc.sentences.flatMap((sentence) => {
+    const inSentence = within(sentence.span, amounts);
+    const [head] = inSentence;
+    return head === undefined ? [] : [{ text: sentence.text, scope: scopes.get(head.start) ?? "", amounts: inSentence }];
+  });
+
+const subjectWordsOf = (doc: ProseDocument): SubjectWords => ({
+  separators: patternsOf(doc, "fact-separator"),
+  determiners: patternsOf(doc, "fact-label-drop"),
+  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 }));
+
+/** 金額: 通貨の語彙表の印を単位に書いた数量。前後に期間あたりの印があれば、その期間も。 */
+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 };
+    });
+};
+
+/** 表の行の金額と、その行の見出しを主語にした文の金額の食い違い。名前付きの値として読めた文の値は、ほかの読みが比べる。 */
+export const rowSentenceFindings = (doc: ProseDocument, facts: readonly ScopedFact[]): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const amounts = amountsOf(doc, tree);
+  const tableRows = tablesOf(linesOf(doc.source)).flatMap((table) => table.rows);
+  if (tableRows.length === 0 || amounts.length === 0) return [];
+  const scopes = scopesAt(doc, tree, amounts);
+  const rows = tableRows.flatMap((row) => amountRow(row, amounts, scopes));
+  const read = new Set(facts.map((fact) => fact.value.start));
+  return rowSentenceConflicts(rows, subjectSentences(doc, amounts, scopes), subjectWordsOf(doc))
+    .filter((conflict) => !read.has(conflict.value.start))
+    .map(({ label, value, other }) => ({
+      rule: "fact-conflict",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, value.start),
+      variant: "term",
+      values: { label, value: doc.source.slice(value.start, value.end), other: doc.source.slice(other.start, other.end), offset: value.start },
+    }));
+};

package/src/detectors/running-balance.ts

@@ -0,0 +1,31 @@
+// running-balance-mismatch: the reading half. Reads the document's Markdown tables and the lexicons balance-column and
+// total-label, and leaves the deciding to structure/running-balance.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { runningBalanceMismatches, type BalanceRole, type BalanceWord } from "../structure/running-balance.ts";
+
+const RULE = "running-balance-mismatch";
+const ROLES: readonly string[] = ["date", "sequence", "balance", "interest", "principal", "in", "out", "payment"] satisfies readonly BalanceRole[];
+const isRole = (group: string | undefined): group is BalanceRole => group !== undefined && ROLES.includes(group);
+
+/** Lexicon balance-column: the heading words that say which column holds the balance and which the movement of a row. */
+const columnWordsOf = (doc: ProseDocument): BalanceWord[] =>
+  (doc.lexicons["balance-column"] ?? []).flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : []));
+
+export const runningBalance: Detector = (doc): Finding[] => {
+  const columns = columnWordsOf(doc);
+  if (columns.length === 0) return [];
+  const tables = tablesOf(linesOf(proseAndTablesOf(doc))).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+  const totalLabels = (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern);
+  return runningBalanceMismatches(tables, { columns, totalLabels }).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/scaled-quantity.ts

@@ -5,7 +5,7 @@ import type { MeasureUnit } from "../facts/measures.ts";
 import { quoteAt } from "./structure-tree.ts";
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 
-const DIMENSIONS = ["unit-mass", "unit-volume"] as const;
+const DIMENSIONS = ["unit-mass", "unit-volume", "unit-area"] as const;
 
 const measuresOf = (doc: ProseDocument): MeasureUnit[] =>
   DIMENSIONS.flatMap((dimension) =>

package/src/detectors/serial-range.ts

@@ -0,0 +1,37 @@
+// serial-range-reversed: a range of serial, lot or batch codes whose end is below its start (製造番号：A2400〜A1800,
+// "Lots L5240 through L5210"), decided by structure/amount-range.ts as quantity-range-reversed is. The codes are read by
+// structure/serial-range.ts; serial-label names the codes on the line; the joints are range-connector, range-opener,
+// range-closer and quantity-range-word; quantity-change-word's ungrouped words make a pair a change.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { reversedAmountRanges, type AmountRangeWords } from "../structure/amount-range.ts";
+import { labelledRanges, NO_BARE_NUMBER, serialRangeEnds } from "../structure/serial-range.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === undefined).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): AmountRangeWords => ({
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "quantity-range-word")],
+  openers: patternsOf(doc, "range-opener"),
+  closers: patternsOf(doc, "range-closer"),
+  changes: patternsOf(doc, "quantity-change-word"),
+  lowers: [],
+  uppers: [],
+  links: [],
+  scales: [],
+  number: NO_BARE_NUMBER,
+});
+
+export const serialRange: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const reversed = reversedAmountRanges(text, serialRangeEnds(text), wordsOf(doc));
+  return labelledRanges(text, reversed, patternsOf(doc, "serial-label")).map((issue) => ({
+    rule: "serial-range-reversed",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};