chaffjs 0.28.0 → 0.29.0

package/src/structure/action-due.ts

@@ -0,0 +1,179 @@
+import type { MarkupHeading } from "../plugin.ts";
+import { CELL_SEPARATOR } from "./bare-numbers.ts";
+import type { DatedPoint } from "./due-date.ts";
+import type { StructureIssue } from "./issues.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { TABLE_RULE } from "./runs.ts";
+import { isTotalLabel } from "./total.ts";
+
+/**
+ * An action item due before the meeting it was set in. Only minutes are read (a title with 議事録 or Minutes). The meeting
+ * date is the first date on a line starting with a meeting-date word (日時, Date) near the top; the deadlines are those of the action sections (a heading with 宿題 or
+ * Action items): the cell under a due column (期限, Due) of a table, or a date right after a due word in a list item
+ * (（期限 11月2日）, (due Oct 3)). An item marked done, and a section on earlier items (前回の宿題), are not read. Pure.
+ */
+export type ActionWords = {
+  readonly meeting: readonly string[];
+  readonly section: readonly string[];
+  readonly earlier: readonly string[];
+  readonly due: readonly string[];
+  readonly done: readonly string[];
+  readonly minutes: readonly string[];
+};
+
+/** How far from the top the meeting date may be and still be the date of the meeting the minutes record. */
+const MEETING_HEAD_LINES = 12;
+
+/** A deadline without a year this many days or fewer after the meeting, read in the next year, is taken as next year's. */
+const MAX_WRAP_DAYS = 92;
+
+const MS_PER_DAY = 86_400_000;
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+const MONTH_DAY = /^(?:\d{4}-)?(\d{2})-(\d{2})$/u;
+const LIST_ITEM = /^[ \t]*(?:[-*+]|\d{1,3}[.)])[ \t]/u;
+const LATIN_WORD = /^[A-Za-z ]+$/u;
+
+const escaped = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+const hasWord = (text: string, word: string): boolean => (LATIN_WORD.test(word) ? new RegExp(`\\b${escaped(word)}\\b`, "iu").test(text) : text.includes(word));
+
+const hasAny = (text: string, words: readonly string[]): boolean => words.some((word) => hasWord(text, word));
+
+const CHECKED_BOX = /^[ \t]*(?:[-*+]|\d{1,3}[.)])[ \t]+\[[xX]\]/u;
+const BRACKETED = /[(（【[][^()（）【】[\]]*[)）】\]]/gu;
+const TRAIL_SEPARATOR = /[ \t—–:：、,]/u;
+const LINE_CLOSERS = new Set(["|", "。", ".", " ", "\t"]);
+
+/** The last word of a line, without a closing table bar or a full stop. */
+const lastWord = (text: string): string =>
+  (
+    text
+      .slice(0, text.split("").findLastIndex((unit) => !LINE_CLOSERS.has(unit)) + 1)
+      .split(TRAIL_SEPARATOR)
+      .at(-1) ?? ""
+  ).toLowerCase();
+
+const cellTexts = (text: string): string[] =>
+  text.split(CELL_SEPARATOR).map((cell) =>
+    cell
+      .replace(/[*_✔✓]/gu, "")
+      .trim()
+      .toLowerCase(),
+  );
+
+/**
+ * An item marked done: a checked box, a cell that is a done word alone, a done word in brackets (（済）, (done, June 3)),
+ * or one ending the line. A done word inside the task (Complete the review) does not mark it.
+ */
+const isMarkedDone = (text: string, words: readonly string[]): boolean => {
+  if (CHECKED_BOX.test(text)) return true;
+  const alone = new Set(words.map((word) => word.toLowerCase()));
+  return cellTexts(text).some((cell) => alone.has(cell)) || alone.has(lastWord(text)) || [...text.matchAll(BRACKETED)].some((match) => hasAny(match[0], words));
+};
+
+/** Whether the title (the first top-level heading, or else the first line with text) names minutes. */
+const isMinutes = (lines: readonly Line[], headings: readonly MarkupHeading[], words: readonly string[]): boolean =>
+  hasAny(headings.find((heading) => heading.depth === 1)?.text ?? lines.find((line) => line.text.trim() !== "")?.text ?? "", words);
+
+const datesIn = (dates: readonly DatedPoint[], start: number, end: number): DatedPoint[] => dates.filter((date) => date.offset >= start && date.offset <= end);
+
+const meetingDate = (lines: readonly Line[], dates: readonly DatedPoint[], words: readonly string[]): DatedPoint | undefined =>
+  lines
+    .slice(0, MEETING_HEAD_LINES)
+    .filter((line) => isTotalLabel(line.text, words))
+    .map((line) => datesIn(dates, line.start, line.start + line.text.length)[0])
+    .find((date) => date !== undefined);
+
+type Range = { readonly start: number; readonly end: number };
+
+/** Where a heading's section ends: the next heading at its depth or above. */
+const sectionOf = (headings: readonly MarkupHeading[], index: number, end: number): Range => {
+  const heading = headings[index];
+  const next = headings.slice(index + 1).find((later) => heading !== undefined && later.depth <= heading.depth);
+  return { start: heading?.start ?? end, end: next?.start ?? end };
+};
+
+/** The action sections, without the parts under a heading on earlier items. */
+const actionRanges = (headings: readonly MarkupHeading[], length: number, words: ActionWords): { take: Range[]; skip: Range[] } => {
+  const ranges = headings.map((heading, index) => ({ heading, range: sectionOf(headings, index, length) }));
+  return {
+    take: ranges.filter(({ heading }) => hasAny(heading.text, words.section)).map(({ range }) => range),
+    skip: ranges.filter(({ heading }) => hasAny(heading.text, words.earlier)).map(({ range }) => range),
+  };
+};
+
+const inside = (offset: number, ranges: readonly Range[]): boolean => ranges.some((range) => offset >= range.start && offset < range.end);
+
+/** The column of a table header that is a due word alone, if the line is a header (the next line is the table's rule). */
+const dueColumn = (line: Line, next: Line | undefined, words: readonly string[]): number | undefined => {
+  if (next === undefined || !TABLE_RULE.test(next.text) || !line.text.includes("|")) return undefined;
+  const labels = new Set(words.map((word) => word.toLowerCase()));
+  const column = cellTexts(line.text).findIndex((cell) => labels.has(cell));
+  return column < 0 ? undefined : column;
+};
+
+const lineEnd = (line: Line): number => line.start + line.text.length;
+
+const columnAt = (line: Line, offset: number): number => line.text.slice(0, offset - line.start).split(CELL_SEPARATOR).length - 1;
+
+/** The deadline in a table row: the one date in the due column. */
+const rowDeadline = (line: Line, column: number, dates: readonly DatedPoint[]): DatedPoint[] => {
+  const inColumn = datesIn(dates, line.start, lineEnd(line)).filter((date) => columnAt(line, date.offset) === column);
+  return inColumn.length === 1 ? inColumn : [];
+};
+
+/** A due word right before a date, with at most one word between (due Monday, November 2; 期限：11月2日). */
+const dueWordBefore = (words: readonly string[]): RegExp =>
+  new RegExp(`(?:^|[\\s(（、,;:：])(?:${words.map(escaped).join("|")})[ \\t\\u3000:：]*(?:\\p{L}+,?[ \\t]+)?$`, "iu");
+
+/** The deadlines of a list item: the dates right after a due word. */
+const listDeadlines = (line: Line, dates: readonly DatedPoint[], dueBefore: RegExp): DatedPoint[] =>
+  LIST_ITEM.test(line.text) ? datesIn(dates, line.start, lineEnd(line)).filter((date) => dueBefore.test(line.text.slice(0, date.offset - line.start))) : [];
+
+/** The deadlines of the tables with a due column and of the list items, outside items marked done. */
+const deadlinesOf = (lines: readonly Line[], dates: readonly DatedPoint[], words: ActionWords): DatedPoint[] => {
+  const found: DatedPoint[] = [];
+  const dueBefore = dueWordBefore(words.due);
+  lines.reduce<number | undefined>((column, line, index) => {
+    const header = dueColumn(line, lines[index + 1], words.due);
+    if (header !== undefined) return header;
+    const inTable = line.text.includes("|") ? column : undefined;
+    if (isMarkedDone(line.text, words.done)) return inTable;
+    found.push(...(inTable === undefined ? listDeadlines(line, dates, dueBefore) : rowDeadline(line, inTable, dates)));
+    return inTable;
+  }, undefined);
+  return found;
+};
+
+const REFERENCE_YEAR = 2001;
+
+const dayNumber = (value: string, year: number): number | undefined => {
+  const match = MONTH_DAY.exec(value);
+  return match === null ? undefined : Date.UTC(year, Number(match[1]) - 1, Number(match[2])) / MS_PER_DAY;
+};
+
+/** Whether a deadline is before the meeting. Without a year on one of them, a deadline early in the next year is not. */
+export const isBeforeMeeting = (due: string, meeting: string): boolean => {
+  if (FULL_DATE.test(due) && FULL_DATE.test(meeting)) return due < meeting;
+  const meetingDay = dayNumber(meeting, REFERENCE_YEAR);
+  const dueDay = dayNumber(due, REFERENCE_YEAR);
+  const dueNextYear = dayNumber(due, REFERENCE_YEAR + 1);
+  if (meetingDay === undefined || dueDay === undefined || dueNextYear === undefined) return false;
+  return dueDay < meetingDay && dueNextYear - meetingDay > MAX_WRAP_DAYS;
+};
+
+export const actionDueBeforeMeeting = (
+  source: string,
+  dates: readonly DatedPoint[],
+  headings: readonly MarkupHeading[],
+  words: ActionWords,
+): StructureIssue[] => {
+  if (words.meeting.length === 0 || words.due.length === 0 || words.section.length === 0) return [];
+  const lines = linesOf(source);
+  const meeting = meetingDate(lines, dates, words.meeting);
+  const ranges = actionRanges(headings, source.length, words);
+  if (meeting === undefined || ranges.take.length === 0 || !isMinutes(lines, headings, words.minutes)) return [];
+  return deadlinesOf(lines, dates, words)
+    .filter((due) => inside(due.offset, ranges.take) && !inside(due.offset, ranges.skip) && isBeforeMeeting(due.value, meeting.value))
+    .map((due) => ({ offset: due.offset, values: { due: due.value, meeting: meeting.value } }));
+};

package/src/structure/amount-range.ts

@@ -0,0 +1,219 @@
+// amount-range-reversed: a range of amounts whose upper end is below its lower end (月給30万円〜25万円, $90,000–$70,000,
+// 下限30万円・上限25万円). The amounts come read (currency, value, the word of scale they carry); the words that join a range,
+// change a price, and label a bound come from the lexicons. Pure.
+import { escapeRegExp } from "../orthography.ts";
+import { amountValue, type ScaleWord } from "./amount-scale.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/** One amount written with its currency. scale is the value of the word of scale written in it (万, million), if any. */
+export type RangeAmount = {
+  readonly offset: number;
+  readonly end: number;
+  readonly currency: string;
+  readonly value: number;
+  readonly scale: number | undefined;
+  readonly position: "before" | "after";
+};
+
+export type AmountRangeWords = {
+  /** The marks and words that make a range on their own (〜, –, to). */
+  readonly connectors: readonly string[];
+  /** Words that make a range only when a closer follows the second amount (から … まで). */
+  readonly openers: readonly string[];
+  readonly closers: readonly string[];
+  /** Words that, in the same sentence, make a descending pair a change of price and not a range (値下げ, reduced). */
+  readonly changes: readonly string[];
+  /** Labels of the lower and upper bound (下限, min; 上限, max) and the particles that may follow a label (は, of). */
+  readonly lowers: readonly string[];
+  readonly uppers: readonly string[];
+  readonly links: readonly string[];
+  /** The words of scale (万, million, k) and the digits of a number (the currency reader's pattern). */
+  readonly scales: readonly ScaleWord[];
+  readonly number: string;
+};
+
+/** An end that took its word of scale from the other end (30〜25万円) is believed reversed only this close to the other. */
+const MAX_INHERITED_RATIO = 10;
+
+const SEPARATORS = /[\s・、，,;；/／|｜:：=＝()（）「」.．]/gu;
+
+const LATIN = /^[A-Za-z]/u;
+
+/** A Latin word is matched at word edges (cut does not match cutting); other scripts as written. */
+const wordPattern = (word: string): string => {
+  const escaped = escapeRegExp(word.toLowerCase());
+  return LATIN.test(word) ? `(?<![a-z])${escaped}(?![a-z])` : escaped;
+};
+
+const hasWord = (text: string, words: readonly string[]): boolean => words.some((word) => new RegExp(wordPattern(word), "u").test(text.toLowerCase()));
+
+const isOneOf = (text: string, words: readonly string[]): boolean => words.some((word) => word.toLowerCase() === text.toLowerCase());
+
+const lineBounds = (text: string, offset: number): { readonly start: number; readonly end: number } => {
+  const end = text.indexOf("\n", offset);
+  return { start: text.lastIndexOf("\n", offset - 1) + 1, end: end === -1 ? text.length : end };
+};
+
+/** A sentence ends at 。, or at a full stop followed by a capital or the line end (e.g. does not end one). */
+const SENTENCE_END = /[。！？]|[.!?](?=\s+[A-Z]|\s*$)/gu;
+
+/** The sentence holding the range, within its line. */
+const sentenceAround = (text: string, start: number, end: number): string => {
+  const line = lineBounds(text, start);
+  const ends = [...text.slice(line.start, line.end).matchAll(SENTENCE_END)].map((match) => line.start + match.index);
+  const from = ends.filter((at) => at < start).at(-1) ?? line.start;
+  const to = ends.find((at) => at >= end) ?? line.end;
+  return text.slice(from, to);
+};
+
+/** What follows the second amount, on its line, without leading spaces. */
+const restOfLine = (text: string, end: number): string => text.slice(end, lineBounds(text, end).end).trimStart();
+
+const ARITHMETIC = /[=＝]/u;
+
+/** Whether the joint between two ends makes them a range: a connector, or an opener with a closer after the second end. */
+const joinsRange = (joint: string, after: string, words: AmountRangeWords): boolean => {
+  if (joint.includes("\n")) return false;
+  const bare = joint.trim();
+  return isOneOf(bare, words.connectors) || (isOneOf(bare, words.openers) && words.closers.some((closer) => after.startsWith(closer)));
+};
+
+type End = { readonly offset: number; readonly end: number; readonly value: number; readonly inherited: boolean };
+
+type Pair = readonly [End, End];
+
+const pairOf = (low: End, high: End): Pair => [low, high];
+
+/** A number as written, with the value of its word of scale (undefined when it has none). */
+type Reading = { readonly offset: number; readonly end: number; readonly value: number; readonly scale: number | undefined };
+
+const scaleOf = (word: string | undefined, words: AmountRangeWords): number | undefined =>
+  word === undefined ? undefined : words.scales.find((scale) => scale.word.toLowerCase() === word.toLowerCase())?.value;
+
+const alternation = (patterns: readonly string[]): string => patterns.toSorted((left, right) => right.length - left.length).join("|");
+
+const scalePart = (words: AmountRangeWords): string => {
+  const scales = alternation(words.scales.map((scale) => escapeRegExp(scale.word)));
+  return scales === "" ? "" : `(?:\\s?(${scales}))?`;
+};
+
+const jointPart = (words: AmountRangeWords): string => `(\\s?(?:${alternation([...words.connectors, ...words.openers].map(wordPattern))})\\s?)`;
+
+/** A bare number (no currency) and its word of scale, if any. */
+const bareReading = (
+  span: { readonly offset: number; readonly end: number },
+  digits: string,
+  scaleWord: string | undefined,
+  words: AmountRangeWords,
+): Reading | undefined => {
+  const value = amountValue(digits, []);
+  if (value === undefined) return undefined;
+  const scale = scaleOf(scaleWord, words);
+  return { ...span, value: scale === undefined ? value : value * scale, scale };
+};
+
+/** One end of a range written with the word of scale only once: the end without one reads it from the other (30〜25万円, $90–70k). */
+const sharing = (own: Reading, other: Reading): End =>
+  own.scale === undefined && other.scale !== undefined
+    ? { offset: own.offset, end: own.end, value: own.value * other.scale, inherited: true }
+    : { offset: own.offset, end: own.end, value: own.value, inherited: false };
+
+const sharedPair = (first: Reading, second: Reading): Pair => pairOf(sharing(first, second), sharing(second, first));
+
+/** The bare number right before a currency-after amount, joined to it (30〜 before 25万円), sharing its currency. */
+const sharedBefore = (text: string, amount: RangeAmount, floor: number, words: AmountRangeWords): Pair | undefined => {
+  const pattern = new RegExp(`(?<![0-9０-９.,，A-Za-z])(${words.number})${scalePart(words)}${jointPart(words)}$`, "iu");
+  const match = pattern.exec(text.slice(floor, amount.offset));
+  if (match === null || !joinsRange(match[3] ?? "", restOfLine(text, amount.end), words)) return undefined;
+  const offset = floor + match.index;
+  const bare = bareReading({ offset, end: offset + match[0].length - (match[3] ?? "").length }, match[1] ?? "", match[2], words);
+  return bare === undefined ? undefined : sharedPair(bare, amount);
+};
+
+/** The bare number right after a currency-before amount, joined to it ($90–70k), sharing its currency. */
+const sharedAfter = (text: string, amount: RangeAmount, ceiling: number, words: AmountRangeWords): Pair | undefined => {
+  const pattern = new RegExp(`^${jointPart(words)}(${words.number})${scalePart(words)}(?![0-9０-９A-Za-z])`, "iu");
+  const match = pattern.exec(text.slice(amount.end, ceiling));
+  if (match === null || !joinsRange(match[1] ?? "", restOfLine(text, amount.end + match[0].length), words)) return undefined;
+  const bare = bareReading({ offset: amount.end + (match[1] ?? "").length, end: amount.end + match[0].length }, match[2] ?? "", match[3], words);
+  return bare === undefined ? undefined : sharedPair(amount, bare);
+};
+
+const asEnd = (amount: RangeAmount): End => ({ offset: amount.offset, end: amount.end, value: amount.value, inherited: false });
+
+/** Both ends written with their currency, joined by a connector. */
+const writtenPair = (text: string, first: RangeAmount, second: RangeAmount, words: AmountRangeWords): Pair | undefined => {
+  if (first.currency !== second.currency) return undefined;
+  if (!joinsRange(text.slice(first.end, second.offset), restOfLine(text, second.end), words)) return undefined;
+  return pairOf(asEnd(first), asEnd(second));
+};
+
+const isReversed = ([low, high]: Pair): boolean => {
+  if (low.value <= high.value) return false;
+  return !(low.inherited || high.inherited) || low.value / high.value <= MAX_INHERITED_RATIO;
+};
+
+/** A pair is a range in a sentence that changes no price and holds no equation (5,000円-2,000円=3,000円). */
+const readsAsRange = (text: string, [low, high]: Pair, words: AmountRangeWords): boolean => {
+  const start = Math.min(low.offset, high.offset);
+  const end = Math.max(low.end, high.end);
+  const sentence = sentenceAround(text, start, end);
+  return !ARITHMETIC.test(sentence) && !hasWord(sentence, words.changes);
+};
+
+/** The pairs of ends read as ranges: two written amounts, or one written amount and a bare number sharing its currency. */
+const pairsOf = (text: string, amounts: readonly RangeAmount[], words: AmountRangeWords): Pair[] =>
+  amounts.flatMap((amount, index) => {
+    const previous = amounts[index - 1];
+    const next = amounts[index + 1];
+    const floor = Math.max(previous?.end ?? 0, lineBounds(text, amount.offset).start);
+    return [
+      previous === undefined ? undefined : writtenPair(text, previous, amount, words),
+      amount.position === "after" ? sharedBefore(text, amount, floor, words) : undefined,
+      amount.position === "before" ? sharedAfter(text, amount, next?.offset ?? text.length, words) : undefined,
+    ].filter((pair) => pair !== undefined);
+  });
+
+/** Whether the text is only separators, particles, and at most the given label. */
+const onlyLabel = (text: string, labels: readonly string[], words: AmountRangeWords): boolean => {
+  const rest = words.links.reduce((left, link) => left.replace(new RegExp(wordPattern(link), "giu"), " "), text.toLowerCase()).replace(SEPARATORS, "");
+  return rest === "" || isOneOf(rest, labels);
+};
+
+/** The label written right before the amount, past separators and particles: lower, upper, or none. */
+const labelBefore = (text: string, amount: RangeAmount, floor: number, words: AmountRangeWords): "lower" | "upper" | undefined => {
+  const before = text.slice(floor, amount.offset).toLowerCase();
+  const ends = (labels: readonly string[]): boolean =>
+    labels.some((label) => {
+      const match = new RegExp(`^[^]*${wordPattern(label)}([^]*)$`, "u").exec(before);
+      return match !== null && onlyLabel(match[1] ?? "", [], words);
+    });
+  if (ends(words.lowers)) return "lower";
+  return ends(words.uppers) ? "upper" : undefined;
+};
+
+/** Two adjacent amounts on one line labelled lower and upper bound (下限30万円・上限25万円), in either order. */
+const labelledPairs = (text: string, amounts: readonly RangeAmount[], words: AmountRangeWords): Pair[] =>
+  amounts.slice(1).flatMap((second, index) => {
+    const first = amounts[index];
+    if (first === undefined || first.currency !== second.currency || text.slice(first.end, second.offset).includes("\n")) return [];
+    const floor = Math.max(amounts[index - 1]?.end ?? 0, lineBounds(text, first.offset).start);
+    const firstLabel = labelBefore(text, first, floor, words);
+    const secondLabel = labelBefore(text, second, first.end, words);
+    if (firstLabel === undefined || secondLabel === undefined || firstLabel === secondLabel) return [];
+    if (!onlyLabel(text.slice(first.end, second.offset), [...words.lowers, ...words.uppers], words)) return [];
+    return [firstLabel === "lower" ? pairOf(asEnd(first), asEnd(second)) : pairOf(asEnd(second), asEnd(first))];
+  });
+
+const issueOf = (text: string, [low, high]: Pair): StructureIssue => {
+  const start = Math.min(low.offset, high.offset);
+  return { offset: start, values: { range: text.slice(start, Math.max(low.end, high.end)).trim() } };
+};
+
+/** The ranges of amounts, written or labelled, whose upper end is below the lower one, once per place, in document order. */
+export const reversedAmountRanges = (text: string, amounts: readonly RangeAmount[], words: AmountRangeWords): StructureIssue[] =>
+  [...pairsOf(text, amounts, words), ...labelledPairs(text, amounts, words)]
+    .filter((pair) => isReversed(pair) && readsAsRange(text, pair, words))
+    .map((pair) => issueOf(text, pair))
+    .toSorted((left, right) => left.offset - right.offset)
+    .filter((issue, index, issues) => issues[index - 1]?.offset !== issue.offset);

package/src/structure/amount-scale.ts

@@ -73,6 +73,24 @@ export const scaleMixes = (amounts: readonly ScaledAmount[]): ScaleMix[] => {
     .toSorted((left, right) => left.odd.offset - right.odd.offset);
 };
 
+/** The largest number of significant digits a round figure has (130万円, $1.5 million): a rounded total or a cap. */
+const ROUND_DIGITS = 2;
+
+/**
+ * Leaves out a round figure in the text (約130万円, a cap of $1.5 million) whose only evidence is the exact amounts of a
+ * table, none of them the same amount: the text gives the round size and the table the detail, which is not one amount
+ * written two ways. The same amount in the table (220万円 and 2,200,000円) stays a mix, and so does a mix within the text.
+ */
+export const withoutRoundTextFigures = (mixes: readonly ScaleMix[], amounts: readonly ScaledAmount[], inTable: (amount: ScaledAmount) => boolean): ScaleMix[] =>
+  mixes.filter(({ odd }) => {
+    if (inTable(odd) || significantDigits(odd.value) > ROUND_DIGITS) return true;
+    const others = amounts.filter(
+      (amount) =>
+        comparable(amount) && amount.currency === odd.currency && magnitudeOf(amount.value) === magnitudeOf(odd.value) && isScaled(amount) !== isScaled(odd),
+    );
+    return others.some((amount) => !inTable(amount) || amount.value === odd.value);
+  });
+
 /** A word of scale and the value it multiplies by (万 10000, million 1000000). */
 export type ScaleWord = { readonly word: string; readonly value: number };
 

package/src/structure/cite.ts

@@ -4,14 +4,18 @@ import { lineStarts, placeOf } from "../position.ts";
 // 回答の引用が原文にあるか。番地が木にあり、引用した文がその番地の範囲に書かれていれば一致。
 // 意味が合っているかは見ない。書いてあるかどうかだけを、機械で決める。
 
+/** address: where in the source the quote is, as `chaff tree` names it. Empty: anywhere in the source. */
 export type Citation = { readonly address: string; readonly quote: string };
 
+/** The address a citation leaves empty: it says the quote is somewhere in the source, not where. */
+export const isAnywhere = (citation: Citation): boolean => citation.address.trim() === "";
+
 export type CitationStatus = "ok" | "missing-address" | "quote-elsewhere" | "quote-not-found";
 
 export type CitationResult = {
   readonly citation: Citation;
   readonly status: CitationStatus;
-  /** 引用文が原文で見つかった位置の、いちばん内側の番地。quote-elsewhere のとき、本当はどこに書いてあるか。 */
+  /** 引用文が原文で見つかった位置の、いちばん内側の番地。quote-elsewhere のとき、本当はどこに書いてあるか。番地を書かない引用では、見つかった場所。 */
   readonly foundAt?: string;
   /** 引用文が見つかった行。引用文が空なら、番地の行。 */
   readonly line?: number;
@@ -84,9 +88,23 @@ const innermostHolding = (nodes: readonly Addressed[], occurrence: Occurrence):
     .filter(({ node }) => within(node, occurrence))
     .reduce<Addressed | undefined>((best, current) => (best === undefined || current.depth > best.depth ? current : best), undefined)?.node.address;
 
+/**
+ * 番地を書かない引用。原文のどこかに書いてあれば一致で、見つかった場所の番地と行を添える。番地の無い原文（見出しの無い記事）にも使える。
+ * 引用文も空なら、何も示していないので番地が無いとする。一致にすると、書き忘れた引用が通る。
+ */
+const anywhere = (citation: Citation, whole: Normalized, nodes: readonly Addressed[], starts: readonly number[]): CitationResult => {
+  const key = normalize(citation.quote).text;
+  if (key === "") return { citation, status: "missing-address" };
+  const at = whole.text.indexOf(key);
+  if (at === -1) return { citation, status: "quote-not-found" };
+  const occurrence = { start: whole.index[at] ?? 0, last: whole.index[at + key.length - 1] ?? 0 };
+  const foundAt = innermostHolding(nodes, occurrence);
+  return { citation, status: "ok", line: placeOf(starts, occurrence.start).line, ...(foundAt === undefined ? {} : { foundAt }) };
+};
+
 /**
  * 引用を一件ずつ確かめる。source は木を作った原文そのもの。
- * 引用文が空（空白だけ）なら番地だけを確かめる。同じ番地が二つある（附則が第1条から振り直す）ときは、どちらかにあれば一致。
+ * 引用文が空（空白だけ）なら番地だけを確かめる。番地が空なら、原文のどこかにあるかだけを確かめる。同じ番地が二つある（附則が第1条から振り直す）ときは、どちらかにあれば一致。
  * 原文は一度だけ揃え、引用ごとには番地の範囲を揃え直さない。長い契約書に引用が何百とあっても、引用ごとの代金は原文の長さに比例するだけ。
  */
 export const checkCitations = (source: string, tree: StructureNode, citations: readonly Citation[]): CitationResult[] => {
@@ -100,6 +118,7 @@ export const checkCitations = (source: string, tree: StructureNode, citations: r
   const whole = normalize(source);
   const starts = lineStarts(source);
   return citations.map((citation): CitationResult => {
+    if (isAnywhere(citation)) return anywhere(citation, whole, nodes, starts);
     // 第 1 項に番号の無い書き方では、「12.1」は第12条そのもの。参照の fallback と同じに読む。
     const firstParagraph = citation.address.endsWith(".1") ? byAddress.get(citation.address.slice(0, -2)) : undefined;
     const candidates = byAddress.get(citation.address) ?? firstParagraph ?? [];

package/src/structure/counted-amounts.ts

@@ -0,0 +1,42 @@
+import type { Amount } from "./total.ts";
+
+/**
+ * 数を足してよい助数詞（16単位、4コマ、3 credits）が付いた数。解析器が助数詞と読まない語（単位、コマ）もここで数量にする。
+ * 助数詞の語は total-mismatch の語彙表（summed-counter）から取る。同じ組（group）の語（credit と credits）は同じ単位として足す。
+ */
+export type SummedCounter = { readonly pattern: string; readonly unit: string };
+
+/** 前に英字や数や小数点が続く数（v2、A4、1.2.3 の 2）は読まない。日本語は数の前に空白を置かないので、仮名や漢字の後ろはよい。 */
+const NUMBER = /(?<![\p{Script=Latin}\p{N}.,．，])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
+
+/** 助数詞に文字や数、つなぎの - _ が詰めて続くもの（3単位目、4コマ漫画、3 unit-priced）は、別の語の一部。 */
+const CONTINUES_WORD = /^[\p{L}\p{N}_-]/u;
+
+/** 序数の印（第3回）。 */
+const ORDINAL_MARK = "第";
+
+/** 助数詞を探す長さ。どの助数詞よりも長い。 */
+const LOOKAHEAD = 32;
+
+const valueOf = (written: string): number => Number(written.normalize("NFKC").replace(/,/gu, ""));
+
+/** 数のすぐ後ろ（空白一つまで）の助数詞。長い語から試す。大文字小文字は区別しない（4 Credits）。 */
+const counterAfter = (source: string, end: number, counters: readonly SummedCounter[]): { unit: string; end: number } | undefined => {
+  const gap = source.charAt(end) === " " ? 1 : 0;
+  const rest = source.slice(end + gap, end + gap + LOOKAHEAD).toLowerCase();
+  const counter = counters.find((candidate) => rest.startsWith(candidate.pattern.toLowerCase()) && !CONTINUES_WORD.test(rest.slice(candidate.pattern.length)));
+  return counter === undefined ? undefined : { unit: counter.unit, end: end + gap + counter.pattern.length };
+};
+
+const overlapsAny = (start: number, end: number, amounts: readonly Amount[]): boolean => amounts.some((amount) => start < amount.end && amount.offset < end);
+
+/** 文書の中の、足してよい助数詞の付いた数。木がすでに数量として読んだもの（known）とは重ねない。 */
+export const countedAmounts = (source: string, counters: readonly SummedCounter[], known: readonly Amount[]): Amount[] => {
+  const longestFirst = counters.toSorted((left, right) => right.pattern.length - left.pattern.length);
+  return [...source.matchAll(NUMBER)].flatMap((match): Amount[] => {
+    if (source.charAt(match.index - 1) === ORDINAL_MARK) return [];
+    const found = counterAfter(source, match.index + match[0].length, longestFirst);
+    if (found === undefined || overlapsAny(match.index, found.end, known)) return [];
+    return [{ offset: match.index, end: found.end, value: valueOf(match[0]), unit: found.unit }];
+  });
+};

package/src/structure/date-order.ts

@@ -1,9 +1,11 @@
 import type { StructureIssue } from "./issues.ts";
-import { runsOf, type Line } from "./runs.ts";
+import { siblingHeadingRunsOf } from "./heading-runs.ts";
+import { runsOf } from "./runs.ts";
 
 /**
- * 日程として並べた日付の順番。箇条書きの続いた項目か、表の続いた行で、日付をちょうど一つ持つものを並びとして読む。
- * 並びの向き（古い順か新しい順か）は多いほうで決め、それに逆らう一歩だけを言う。新しい順に並べた履歴は正しい並び。
+ * 日程として並べた日付の順番。箇条書きの続いた項目、表の続いた行、同じ親の下で同じ深さに並ぶ見出しで、
+ * 日付をちょうど一つ持つものを並びとして読む。
+ * 並びの向き（古い順か新しい順か）は多いほうで決め、それに逆らう一歩ごとに、その前後のうち並びから外れた日付を言う。新しい順に並べた履歴は正しい並び。
  * 向きが決まらない並び（上がりと下がりが同じ数）は何も言わない。逆らう一歩を言えるのは、日付が 4 つ以上の並びだけになる。
  * 向きに沿って並ぶ日付が半分以下の並びは、日付でなく別のもの（名前、版）で並べた一覧として何も言わない。
  */
@@ -12,13 +14,41 @@ export type DatedPoint = { readonly offset: number; readonly value: string };
 /** 並びとして比べられる日付の書き方。年月日、年月、月日は、同じ書き方どうしでしか比べない。 */
 const PRECISIONS = [/^\d{4}-\d{2}-\d{2}$/u, /^\d{4}-\d{2}$/u, /^\d{2}-\d{2}$/u];
 
-/** 行ごとの日付。ちょうど一つの行だけを並びに入れる。二つある行（期間）はどちらを並べたのか決められない。 */
-const datedLines = (run: readonly Line[], points: readonly DatedPoint[]): DatedPoint[] =>
+/** 並びの一行（箇条書きの項目、表の行、見出し）の原文の範囲。 */
+type Span = { readonly start: number; readonly end: number };
+
+/** 見出しの深さと原文の範囲。 */
+export type HeadingSpan = Span & { readonly depth: number };
+
+/**
+ * 同じ親の下で同じ深さに並ぶ見出し（変更履歴の版ごとの見出し）。浅い見出しが来たら、それより深い並びは閉じる。
+ * 深い見出し（### 追加）は並びを切らず、親ごとに別の並びになる。
+ */
+export const siblingHeadingRuns = (headings: readonly HeadingSpan[]): HeadingSpan[][] => siblingHeadingRunsOf(headings, (heading) => heading);
+
+/** 一行のただ一つの日付。二つある行（期間）はどちらを並べたのか決められないので、並びに入れない。 */
+const onlyDateIn = (line: Span, points: readonly DatedPoint[]): DatedPoint | undefined => {
+  const inside = points.filter((point) => point.offset >= line.start && point.offset <= line.end);
+  return inside.length === 1 ? inside[0] : undefined;
+};
+
+const datedLines = (run: readonly Span[], points: readonly DatedPoint[]): DatedPoint[] =>
   run.flatMap((line) => {
-    const inside = points.filter((point) => point.offset >= line.start && point.offset <= line.end);
-    return inside.length === 1 && inside[0] !== undefined ? [inside[0]] : [];
+    const date = onlyDateIn(line, points);
+    return date === undefined ? [] : [date];
   });
 
+/** 見出しの並びは、日付を一つ持つ見出しが続くあいだだけ。日付の無い見出しが混じる並び（問いに更新日を添えた FAQ）は、日付で並べたものではない。 */
+const datedStretches = (run: readonly Span[], points: readonly DatedPoint[]): DatedPoint[][] =>
+  run.reduce<DatedPoint[][]>(
+    (stretches, heading) => {
+      const date = onlyDateIn(heading, points);
+      if (date === undefined) return [...stretches, []];
+      return [...stretches.slice(0, -1), [...(stretches.at(-1) ?? []), date]];
+    },
+    [[]],
+  );
+
 const samePrecision = (dated: readonly DatedPoint[]): boolean => PRECISIONS.some((pattern) => dated.every((point) => pattern.test(point.value)));
 
 /** 上がりが多ければ 1、下がりが多ければ -1、同じ数なら 0（向きを決めない）。 */
@@ -37,23 +67,43 @@ export const longestInOrder = (values: readonly string[], direction: number): nu
 /** 日付のうち向きに沿うものが過半を占める。ひとつふたつの書き間違いなら残りが揃うが、名前順の一覧は揃わない。 */
 const mostlyInOrder = (values: readonly string[], direction: number): boolean => longestInOrder(values, direction) * 2 > values.length;
 
-/** 多いほうの向きに逆らう一歩。後ろの項目の日付を指す。 */
+const without = (values: readonly string[], index: number): string[] => values.filter((_, at) => at !== index);
+
+/**
+ * 向きに逆らう一歩（at - 1 から at）のうち、並びから外れているほう。取り除いたとき残りが長く揃うほうを指す。
+ * 前を取っても後ろを取っても同じだけ揃う（隣どうしの入れ替わり）なら、どちらとも決められないので後ろを指す。
+ */
+export const outOfPlace = (values: readonly string[], at: number, direction: number): number =>
+  longestInOrder(without(values, at - 1), direction) > longestInOrder(without(values, at), direction) ? at - 1 : at;
+
+/** 外れた日付に、前の日付を添える。先頭の日付には前が無いので、次の日付を添える。 */
+const issueAt = (dated: readonly DatedPoint[], at: number): StructureIssue[] => {
+  const point = dated[at];
+  if (point === undefined) return [];
+  const neighbour = at === 0 ? { next: dated[1]?.value ?? "" } : { previous: dated[at - 1]?.value ?? "" };
+  return [{ offset: point.offset, values: { date: point.value, ...neighbour } }];
+};
+
+/** 多いほうの向きに逆らう一歩ごとに、並びから外れた日付を指す。 */
 const againstMajority = (dated: readonly DatedPoint[]): StructureIssue[] => {
-  const steps = dated
-    .slice(1)
-    .map((point, index) => ({ point, previous: dated[index], sign: Math.sign(point.value.localeCompare(dated[index]?.value ?? "")) }));
-  const up = steps.filter((step) => step.sign > 0).length;
-  const down = steps.filter((step) => step.sign < 0).length;
-  const majority = majorityOf(up, down);
   const values = dated.map((point) => point.value);
+  const signs = values.slice(1).map((value, index) => Math.sign(value.localeCompare(values[index] ?? "")));
+  const majority = majorityOf(signs.filter((sign) => sign > 0).length, signs.filter((sign) => sign < 0).length);
   if (majority === 0 || !mostlyInOrder(values, majority)) return [];
-  return steps
-    .filter((step) => step.sign === -majority)
-    .map((step) => ({ offset: step.point.offset, values: { date: step.point.value, previous: step.previous?.value ?? "" } }));
+  return signs.flatMap((sign, index) => {
+    if (sign !== -majority) return [];
+    return issueAt(dated, outOfPlace(values, index + 1, majority));
+  });
 };
 
-export const dateOrderBreaks = (source: string, points: readonly DatedPoint[]): StructureIssue[] =>
-  runsOf(source).flatMap((run) => {
-    const dated = datedLines(run, points);
-    return samePrecision(dated) ? againstMajority(dated) : [];
-  });
+const breaksIn = (dated: readonly DatedPoint[]): StructureIssue[] => (samePrecision(dated) ? againstMajority(dated) : []);
+
+/** 見出しを箇条書きの中に書けば（「- ## 3.1.0 - 2026-10-02」）、同じ日付が両方の並びに入る。一度だけ言う。 */
+const oncePerOffset = (issues: readonly StructureIssue[]): StructureIssue[] =>
+  issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
+
+export const dateOrderBreaks = (source: string, points: readonly DatedPoint[], headings: readonly HeadingSpan[] = []): StructureIssue[] =>
+  oncePerOffset([
+    ...runsOf(source).flatMap((run) => breaksIn(datedLines(run, points))),
+    ...siblingHeadingRuns(headings).flatMap((run) => datedStretches(run, points).flatMap(breaksIn)),
+  ]);