chaffjs 0.30.0 → 0.32.0

package/src/structure/period-label-conflict.ts

@@ -0,0 +1,174 @@
+import { escapeRegExp } from "../orthography.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { periodLabelsIn, type CompiledFrame, type PeriodLabel } from "./period-labels.ts";
+import { afterLabel } from "./stated-period.ts";
+
+// 決算の文書が題で言った期間（2027年3月期 第2四半期、Q2 FY2026）と、今の業績を言う所に書いた同じ種類の別の期間（第3四半期、FY2025）。
+// 純関数: 文書の字、文と見出しの範囲、語彙表の語を受け取る。
+// 文書の期間は、題（最初の字のある行）が業績の語（決算、業績、Financial Results）と一緒に書いた期間の名前。
+// 題に無い種類は、頭の「対象期間：」「Reporting period:」の一行から補う。題に同じ種類の違う期間が二つあれば、その種類は比べない。
+// 書き方そのものが文書の年を言う名前（令和8年分、Tax Year 2026）は、業績の語が無い題からも読み、本文のどの文の中でも比べる。
+
+export type ReportingWords = {
+  readonly frames: readonly CompiledFrame[];
+  /** 業績を言う語。題がこれを持つ文書だけを読み、文がこれを持てば今の業績を言う文と読む。 */
+  readonly results: readonly string[];
+  /** 文書の期間を書く行の頭の語（対象期間、Reporting period）。 */
+  readonly periodLines: readonly string[];
+  /** 比べる相手の期間を言う語（前年同期、prior year）。 */
+  readonly comparisons: readonly string[];
+  /** 先の期間の見込みを言う語（通期予想、outlook）。 */
+  readonly forecasts: readonly string[];
+  /** 今の期間を指す語（当期、当第、this quarter）。 */
+  readonly currents: readonly string[];
+  /** 今の期間の語を含むが期間を指さない語（当期純利益）。 */
+  readonly notCurrents: readonly string[];
+  /** 期間の名前の書き方を含むが名前ではない語（分担金の「年分担」）。 */
+  readonly notNames: readonly string[];
+};
+
+export type Span = { readonly start: number; readonly end: number };
+export type Heading = Span & { readonly text: string };
+
+export type PeriodConflict = { readonly offset: number; readonly label: string; readonly stated: string };
+
+type Unit = {
+  readonly start: number;
+  readonly text: string;
+  readonly headerCell: boolean;
+  /** 文書の期間の名前を探す範囲。表の見出しの升なら行全体（| FY2025 | FY2026 | の FY2025 は比べる相手）。 */
+  readonly context: string;
+  readonly section: string;
+};
+
+const HEAD_LINES = 12;
+const ASCII_EDGE = /[A-Za-z0-9]/u;
+
+const wordRegex = (word: string): RegExp => {
+  const before = ASCII_EDGE.test(word.charAt(0)) ? "(?<![A-Za-z0-9])" : "";
+  const after = ASCII_EDGE.test(word.charAt(word.length - 1)) ? "(?![A-Za-z0-9])" : "";
+  return new RegExp(`${before}${escapeRegExp(word).replaceAll(" ", "\\s+")}${after}`, "iu");
+};
+
+export const hasWord = (text: string, words: readonly string[]): boolean => words.some((word) => word !== "" && wordRegex(word).test(text));
+
+const withoutWords = (text: string, words: readonly string[]): string =>
+  words.filter((word) => word !== "").reduce((rest, word) => rest.replace(new RegExp(wordRegex(word).source, "giu"), " "), text);
+
+const occurrencesOf = (text: string, word: string): Span[] =>
+  word === "" ? [] : [...text.matchAll(new RegExp(escapeRegExp(word), "gu"))].map((match) => ({ start: match.index, end: match.index + word.length }));
+
+/** 名前の終わりが、名前ではない語の途中に落ちるか（令和8年分担金の「令和8年分」）。 */
+const endsInsideNotName = (text: string, label: PeriodLabel, notNames: readonly string[]): boolean =>
+  notNames.some((word) => occurrencesOf(text, word).some((span) => span.start < label.end && label.end < span.end));
+
+const labelsIn = (text: string, words: ReportingWords): PeriodLabel[] =>
+  periodLabelsIn(text, words.frames).filter((label) => !endsInsideNotName(text, label, words.notNames));
+
+const sameLabel = (left: PeriodLabel, right: PeriodLabel): boolean => left.kind === right.kind && left.shape === right.shape && left.value === right.value;
+const sameSlot = (left: PeriodLabel, right: PeriodLabel): boolean => left.kind === right.kind && left.shape === right.shape;
+
+/** 種類と形ごとに一つの期間。同じ種類と形の違う期間が並べば、どちらが文書の期間か決まらないので落とす。 */
+const oneEach = (labels: readonly PeriodLabel[]): PeriodLabel[] =>
+  labels.filter(
+    (label, index) =>
+      labels.every((other) => !sameSlot(other, label) || sameLabel(other, label)) && labels.findIndex((other) => sameLabel(other, label)) === index,
+  );
+
+/** 文書の期間。題が業績の語を持たなければ、書き方そのものが年を言う名前だけ。題に無い種類と形だけを、期間の行から補う。 */
+export const statedPeriodOf = (title: string, periodLine: string, words: ReportingWords): PeriodLabel[] => {
+  const results = hasWord(title, words.results);
+  const readable = (text: string): PeriodLabel[] => oneEach(labelsIn(text, words).filter((label) => results || label.titleAlone));
+  const fromTitle = readable(title);
+  if (fromTitle.length === 0 && !results) return [];
+  const fromLine = readable(periodLine).filter((label) => !fromTitle.some((other) => sameSlot(other, label)));
+  return [...fromTitle, ...fromLine];
+};
+
+/** 名前と同じ種類と形で、値の違う文書の期間。 */
+export const conflictingStated = (label: PeriodLabel, stated: readonly PeriodLabel[]): PeriodLabel | undefined => {
+  const slot = stated.find((other) => sameSlot(other, label));
+  return slot === undefined || sameLabel(slot, label) ? undefined : slot;
+};
+
+/**
+ * 今の業績を言う所の名前か。書き方そのものが年を言う名前（2025年分）は、どこに書いても文書の年を言う。年の中の一部（四半期、半期）で文書の期間より前のものは、累計の中の一部や比べる相手のことが多いので、
+ * 今の期間を指す語（当第1四半期）があるときだけ。ほかは、表の見出しの升ならそれだけで、文なら今の期間か業績の語があるとき。
+ */
+export const refersToCurrent = (label: PeriodLabel, stated: PeriodLabel, unit: Pick<Unit, "text" | "headerCell">, words: ReportingWords): boolean => {
+  const current = hasWord(withoutWords(unit.text, words.notCurrents), words.currents);
+  if (label.withinYear && label.order < stated.order) return current;
+  return label.titleAlone || unit.headerCell || current || hasWord(unit.text, words.results);
+};
+
+const isAside = (text: string, words: ReportingWords): boolean => hasWord(text, words.comparisons) || hasWord(text, words.forecasts);
+
+const issuesIn = (unit: Unit, stated: readonly PeriodLabel[], words: ReportingWords): PeriodConflict[] => {
+  if (isAside(unit.text, words) || isAside(unit.section, words)) return [];
+  const named = labelsIn(unit.context, words);
+  return labelsIn(unit.text, words).flatMap((label) => {
+    const statedLabel = conflictingStated(label, stated);
+    if (statedLabel === undefined || named.some((other) => sameLabel(other, statedLabel))) return [];
+    if (!refersToCurrent(label, statedLabel, unit, words)) return [];
+    return [{ offset: unit.start + label.start, label: label.written, stated: statedLabel.written }];
+  });
+};
+
+const RULE_CELL = /^:?-{3,}:?$/u;
+
+/** 表の見出しと本体を分ける行（| --- | :---: |）。 */
+const isTableRule = (text: string): boolean => {
+  const cells = text.trim().replace(/^\|/u, "").replace(/\|$/u, "").split("|");
+  return text.includes("-") && cells.every((cell) => RULE_CELL.test(cell.trim()));
+};
+
+const cellsOf = (line: Line): { readonly start: number; readonly text: string }[] => {
+  const cells: { start: number; text: string }[] = [];
+  let at = line.start;
+  line.text.split("|").forEach((text) => {
+    cells.push({ start: at, text });
+    at += text.length + 1;
+  });
+  return cells.filter((cell) => cell.text.trim() !== "");
+};
+
+/** 表の見出しの行（次の行が |---| の行）の升。 */
+const headerRows = (lines: readonly Line[]): Line[] =>
+  lines.filter((line, index) => line.text.trimStart().startsWith("|") && isTableRule(lines[index + 1]?.text ?? ""));
+
+const sectionAt = (headings: readonly Heading[], offset: number): string => headings.findLast((heading) => heading.start < offset)?.text ?? "";
+
+const headerUnits = (lines: readonly Line[], headings: readonly Heading[]): Unit[] =>
+  headerRows(lines).flatMap((row) =>
+    cellsOf(row).map((cell) => ({ start: cell.start, text: cell.text, headerCell: true, context: row.text, section: sectionAt(headings, cell.start) })),
+  );
+
+const textUnits = (source: string, spans: readonly Span[], headings: readonly Heading[]): Unit[] =>
+  spans.map((span) => {
+    const text = source.slice(span.start, span.end);
+    return { start: span.start, text, headerCell: false, context: text, section: sectionAt(headings, span.start) };
+  });
+
+type Head = { readonly title: string; readonly periodLine: string; readonly end: number };
+
+/** 題（最初の字のある行）と、その後ろ、次の見出しまでの頭の行のうち期間の語で始まる一行。 */
+const headOf = (lines: readonly Line[], headings: readonly Heading[], words: ReportingWords): Head => {
+  const first = lines.find((line) => line.text.trim() !== "");
+  const titleEnd = first === undefined ? 0 : first.start + first.text.length;
+  const bodyStart = headings.find((heading) => heading.start > titleEnd)?.start ?? Number.POSITIVE_INFINITY;
+  const head = lines.filter((line) => line.start > titleEnd && line.start < bodyStart).slice(0, HEAD_LINES);
+  const periodLine = head.find((line) => afterLabel(line.text, words.periodLines) !== undefined);
+  const end = periodLine === undefined ? titleEnd : periodLine.start + periodLine.text.length;
+  return { title: first?.text.replace(/^#+\s*/u, "") ?? "", periodLine: periodLine?.text ?? "", end };
+};
+
+/** 題の期間と同じ種類の別の期間を、今の業績を言う文、見出し、表の見出しの升に書いた所。 */
+export const periodLabelConflicts = (source: string, sentences: readonly Span[], headings: readonly Heading[], words: ReportingWords): PeriodConflict[] => {
+  const lines = linesOf(source);
+  const head = headOf(lines, headings, words);
+  const stated = statedPeriodOf(head.title, head.periodLine, words);
+  if (stated.length === 0) return [];
+  const sections = headings.filter((heading) => heading.start > head.end);
+  const units = [...textUnits(source, [...sentences, ...sections], sections), ...headerUnits(lines, sections)].filter((unit) => unit.start > head.end);
+  return units.flatMap((unit) => issuesIn(unit, stated, words)).toSorted((left, right) => left.offset - right.offset);
+};

package/src/structure/period-labels.ts

@@ -0,0 +1,147 @@
+import { escapeRegExp } from "../orthography.ts";
+
+// 期間の名前（第2四半期、Q2、FY2026、2026年3月期、上期）を読む。純関数: 書き方は語彙表から受け取る。
+// 書き方の {n} は四半期や半期の番号、{y} は年、{e} は期間の終わる年、{m} は月、{_} は値に入らない短い語（Fiscal Year Ending {_} {e} の日付）。
+// FY2026 が 2026 年に始まる年か終わる年かは会社で違うので、{y} の名前と {e} の名前は比べない。
+// 番号を書かない書き方（Second Quarter、上期）は、同じ期間の番号付きの書き方を instead_of に持つ。
+// {y} は元号の年（令和8）でもよく、元年の西暦の年から西暦の年にする（令和8年分と2026年分は同じ年）。
+
+export type PeriodFrame = {
+  readonly pattern: string;
+  readonly kind: string;
+  readonly insteadOf?: string | undefined;
+  /** 題に業績の語が無くても読む書き方（令和8年分、Tax Year 2026）。書き方そのものが文書の年を言う。 */
+  readonly titleAlone?: boolean | undefined;
+};
+
+/** 元号と、その元年の西暦の年（令和は 2019）。 */
+export type Era = { readonly name: string; readonly firstYear: number };
+
+/** 文の中の期間の名前一つ。shape は値に使った部分（y,m なら年と月）で、同じ shape どうしだけを比べる。order は前後を比べる数。 */
+export type PeriodLabel = {
+  readonly start: number;
+  readonly end: number;
+  readonly written: string;
+  readonly kind: string;
+  readonly shape: string;
+  readonly value: string;
+  readonly order: number;
+  /** 年を持たない名前（四半期、半期）。一年の中の一部を言う。 */
+  readonly withinYear: boolean;
+  readonly titleAlone: boolean;
+};
+
+export type CompiledFrame = {
+  readonly regex: RegExp;
+  readonly kind: string;
+  readonly insteadOf: string | undefined;
+  readonly titleAlone: boolean;
+  readonly firstYears: ReadonlyMap<string, number>;
+};
+
+const PLACEHOLDER = /\{([nyem_])\}/gu;
+const SLOT: Readonly<Record<string, string>> = {
+  n: "(?<n>[1-4１-４])",
+  y: "(?<y>[0-9０-９]{4})",
+  e: "(?<e>[0-9０-９]{4})",
+  m: "(?<m>[0-9０-９]{1,2})",
+  _: "[^\\n|。.!?]{1,24}?",
+};
+const ERA_GAP = "[ \\t\\u3000]?";
+const eraYearSlot = (eras: readonly Era[]): string =>
+  eras.length === 0 ? "" : `|(?<era>${eras.map((era) => escapeRegExp(era.name)).join("|")})${ERA_GAP}(?<eraYear>[0-9０-９]{1,2}|元)${ERA_GAP}`;
+
+const slotsFor = (eras: readonly Era[]): Readonly<Record<string, string>> => ({
+  ...SLOT,
+  y: `(?:(?<y>[0-9０-９]{4})${eraYearSlot(eras)})`,
+});
+
+const BEFORE = "(?<![A-Za-z0-9０-９])";
+const AFTER = "(?![A-Za-z0-9０-９])";
+
+const literal = (text: string): string => escapeRegExp(text).replaceAll(" ", "[ \\t\\u00a0]+");
+
+const bodyOf = (pattern: string, slots: Readonly<Record<string, string>>): string =>
+  pattern
+    .split(PLACEHOLDER)
+    .map((piece, index) => (index % 2 === 1 ? (slots[piece] ?? "") : literal(piece)))
+    .join("");
+
+const startsAlnum = (pattern: string): boolean => /^(?:[A-Za-z0-9]|\{[nyem]\})/u.test(pattern);
+const endsAlnum = (pattern: string): boolean => /(?:[A-Za-z0-9]|\{[nyem]\})$/u.test(pattern);
+
+const compile = (frame: PeriodFrame, eras: readonly Era[]): CompiledFrame => ({
+  regex: new RegExp(`${startsAlnum(frame.pattern) ? BEFORE : ""}${bodyOf(frame.pattern, slotsFor(eras))}${endsAlnum(frame.pattern) ? AFTER : ""}`, "giu"),
+  kind: frame.kind,
+  insteadOf: frame.insteadOf,
+  titleAlone: frame.titleAlone === true,
+  firstYears: new Map(eras.map((era) => [era.name, era.firstYear])),
+});
+
+export const compileFrames = (frames: readonly PeriodFrame[], eras: readonly Era[] = []): readonly CompiledFrame[] =>
+  frames.filter((frame) => frame.pattern !== "").map((frame) => compile(frame, eras));
+
+const halfWidth = (digits: string): string => digits.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0));
+
+const KEY_ORDER = ["y", "e", "m", "n"] as const;
+
+type Parts = Readonly<Partial<Record<(typeof KEY_ORDER)[number], number>>>;
+
+type Groups = Readonly<Record<string, string | undefined>> | undefined;
+
+/** 元号の年（令和8）を西暦の年（2026）にする。元年は 1。 */
+const eraYearOf = (groups: Groups, firstYears: ReadonlyMap<string, number>): Parts => {
+  const firstYear = firstYears.get(groups?.["era"] ?? "");
+  const written = groups?.["eraYear"];
+  if (firstYear === undefined || written === undefined) return {};
+  return { y: firstYear + (written === "元" ? 1 : Number(halfWidth(written))) - 1 };
+};
+
+const partsOf = (groups: Groups, firstYears: ReadonlyMap<string, number> = new Map()): Parts => ({
+  ...Object.fromEntries(KEY_ORDER.flatMap((key) => (groups?.[key] === undefined ? [] : [[key, Number(halfWidth(groups[key]))]]))),
+  ...eraYearOf(groups, firstYears),
+});
+
+/** 番号を書かない書き方の値は、instead_of に書いた番号付きの書き方から読む。 */
+const insteadParts = (insteadOf: string, frames: readonly CompiledFrame[], kind: string): Parts | undefined => {
+  const frame = frames.find(
+    (candidate) => candidate.kind === kind && candidate.insteadOf === undefined && new RegExp(`^(?:${candidate.regex.source})$`, "iu").test(insteadOf),
+  );
+  if (frame === undefined) return undefined;
+  return partsOf(new RegExp(`^(?:${frame.regex.source})$`, "iu").exec(insteadOf)?.groups, frame.firstYears);
+};
+
+const labelOf = (match: RegExpExecArray, parts: Parts, frame: CompiledFrame): PeriodLabel | undefined => {
+  const keys = KEY_ORDER.filter((key) => parts[key] !== undefined);
+  if (keys.length === 0) return undefined;
+  return {
+    start: match.index,
+    end: match.index + match[0].length,
+    written: match[0],
+    kind: frame.kind,
+    shape: keys.join(","),
+    value: keys.map((key) => `${key}${String(parts[key])}`).join(","),
+    order: keys.reduce((sum, key) => sum * 100 + (parts[key] ?? 0), 0),
+    withinYear: parts.y === undefined && parts.e === undefined,
+    titleAlone: frame.titleAlone,
+  };
+};
+
+const matchesOf = (text: string, frame: CompiledFrame, frames: readonly CompiledFrame[]): PeriodLabel[] =>
+  [...text.matchAll(frame.regex)].flatMap((match) => {
+    const parts = frame.insteadOf === undefined ? partsOf(match.groups, frame.firstYears) : insteadParts(frame.insteadOf, frames, frame.kind);
+    const label = parts === undefined ? undefined : labelOf(match, parts, frame);
+    return label === undefined ? [] : [label];
+  });
+
+const overlaps = (left: PeriodLabel, right: PeriodLabel): boolean => left.start < right.end && right.start < left.end;
+
+/** 文の中の期間の名前。同じ種類の名前が重なれば長いほう（Fiscal Year Ending … 2027 の中の Year Ending … 2027 は一つ）。 */
+export const periodLabelsIn = (text: string, frames: readonly CompiledFrame[]): PeriodLabel[] => {
+  const all = frames.flatMap((frame) => matchesOf(text, frame, frames)).toSorted((left, right) => right.written.length - left.written.length);
+  const kept: PeriodLabel[] = [];
+  all.forEach((label) => {
+    if (!kept.some((other) => other.kind === label.kind && overlaps(other, label))) kept.push(label);
+  });
+  return kept.toSorted((left, right) => left.start - right.start);
+};

package/src/structure/period-multiple.ts

@@ -0,0 +1,186 @@
+import type { StructureIssue } from "./issues.ts";
+import { alternation, intervalOf, isMultiple, isPlainGap, nearestStated, occurrences, type Interval, type Span, type StatedAmount } from "./stated-multiple.ts";
+
+/**
+ * period-multiple-mismatch: an amount the text says is a number of another period's amount that is not that many of it
+ * (年払（月払の12か月分） 29,800円 with 月払 2,400円; "Annually (12 monthly payments) $298" with Monthly $24). Only an
+ * explicit statement is read: the base's own word beside a count and a word of a multiple (月払の12か月分, 12 times the
+ * monthly premium, 12 monthly payments). An annual amount that only stands beside a monthly one is not compared, since
+ * paying at once is often cheaper. The base is the nearest one stated before (one label, one amount), else the document's
+ * one base. A range of counts, a statement with two amounts, and a statement with a word that makes the amount another
+ * thing (割引, tax, each) are not compared. The words come from the lexicons. Pure.
+ */
+
+export type PeriodMultipleWords = {
+  /** Labels of the base amount, also its words in a multiple (月払, 月額, Monthly, monthly payments). */
+  readonly bases: readonly string[];
+  /** Words after a count that make it a multiple (か月分, 倍, times). */
+  readonly times: readonly string[];
+  /** Words that may stand between a base and its count (の, the), or between a base label and its amount (は, is). */
+  readonly links: readonly string[];
+  /** Words that make the amount something other than the plain multiple (割引, 税込, discount, each). */
+  readonly skips: readonly string[];
+  /** Marks and words that join the two ends of a range (〜, to). */
+  readonly connectors: readonly string[];
+  /** Numbers written as words (twelve, 十二) and their values. */
+  readonly numberWords: readonly { readonly word: string; readonly value: number }[];
+};
+
+/** A count read as a multiple of a base (月払の12か月分, 12 monthly payments). */
+export type Phrase = Span & { readonly count: number };
+
+/** A base as stated. range is undefined when its statement holds more than one amount or a word that makes it another. */
+type Base = { readonly offset: number; readonly label: string; readonly currency: string; readonly range: Interval | undefined; readonly written: string };
+
+type Count = Span & { readonly count: number; readonly timed: boolean };
+
+const DIGITS = "[0-9０-９]+(?:[.．][0-9０-９]+)?";
+/** A count right after one of these is the tail of a larger number (十二, 二百), not a count of its own. */
+const KANJI_NUMERALS = "〇零一二三四五六七八九十百千万";
+const RANGE_START_DIGIT = /[0-9０-９一二三四五六七八九十]\s*$/u;
+const SENTENCE_END = /[。！？；;]|[.!?](?=\s|$)/gu;
+/** Between a phrase and its amount only marks may stand: brackets, a cell's bar, a colon (（月払の12か月分） | 29,800円). */
+const MARKS_ONLY = /^[\s|｜:：=＝、，,()（）[\]［］]*$/u;
+const SPACES_ONLY = /^[ \t\u3000]+$/u;
+/** How far before a count the start of a range (11〜12か月分) is looked for. */
+const RANGE_REACH = 12;
+
+const lineBounds = (text: string, offset: number): Span => {
+  const end = text.indexOf("\n", offset);
+  return { start: text.lastIndexOf("\n", offset - 1) + 1, end: end === -1 ? text.length : end };
+};
+
+/** The sentence around a span, within its line. */
+export const sentenceAround = (text: string, span: Span): Span => {
+  const line = lineBounds(text, span.start);
+  const ends = [...text.slice(line.start, line.end).matchAll(SENTENCE_END)].map((match) => line.start + match.index);
+  const start = ends.filter((end) => end < span.start).at(-1);
+  const end = ends.find((at) => at >= span.end);
+  return { start: start === undefined ? line.start : start + 1, end: end ?? line.end };
+};
+
+const countOf = (written: string, words: PeriodMultipleWords): number =>
+  words.numberWords.find((entry) => entry.word.toLowerCase() === written.toLowerCase())?.value ?? Number(written.normalize("NFKC"));
+
+/** Every count in the text (12, twelve), marked when a word of a multiple follows it (12か月分, 12 times). */
+export const countsIn = (text: string, words: PeriodMultipleWords): Count[] => {
+  const numberWords = alternation(words.numberWords.map((entry) => entry.word));
+  const count = numberWords === undefined ? DIGITS : `${DIGITS}|${numberWords}`;
+  const times = alternation(words.times);
+  const tail = times === undefined ? "" : `(\\s?(?:${times}))?`;
+  const pattern = new RegExp(`(?<![0-9０-９.,，．${KANJI_NUMERALS}])(${count})(?![0-9０-９]|[.,，．][0-9０-９])${tail}`, "giu");
+  return [...text.matchAll(pattern)].map((match) => ({
+    start: match.index,
+    end: match.index + match[0].length,
+    count: countOf(match[1] ?? "", words),
+    timed: match[2] !== undefined,
+  }));
+};
+
+/** Whether only link words and spaces stand between a base word and its count, on one line (の, " the "). */
+const isLinkGap = (gap: string, words: PeriodMultipleWords): boolean => {
+  if (gap.includes("\n")) return false;
+  const pattern = alternation(words.links);
+  return (pattern === undefined ? gap : gap.replace(new RegExp(pattern, "giu"), "")).trim() === "";
+};
+
+/** Whether a count closes a range: a connector right before it with a number before that (11〜12, eleven to twelve; not "equal to 12"). */
+const endsRange = (text: string, count: Count, words: PeriodMultipleWords): boolean => {
+  const before = text.slice(Math.max(0, count.start - RANGE_REACH), count.start).trimEnd();
+  const endsNumber = (head: string): boolean =>
+    RANGE_START_DIGIT.test(head) || countsIn(head.trimEnd(), words).some((found) => found.end === head.trimEnd().length);
+  return words.connectors.some((connector) => before.toLowerCase().endsWith(connector.toLowerCase()) && endsNumber(before.slice(0, -connector.length)));
+};
+
+/** The base word a count is a multiple of: before it with a word of a multiple (月払の12か月分), or after it (12 monthly payments). */
+const baseOf = (text: string, count: Count, bases: readonly Span[], words: PeriodMultipleWords): Span | undefined => {
+  const after = bases.find(
+    (base) =>
+      base.start >= count.end && (count.timed ? isLinkGap(text.slice(count.end, base.start), words) : SPACES_ONLY.test(text.slice(count.end, base.start))),
+  );
+  if (after !== undefined) return after;
+  return count.timed ? bases.findLast((base) => base.end <= count.start && isLinkGap(text.slice(base.end, count.start), words)) : undefined;
+};
+
+/** Every count stated as a multiple of a base word (月払の12か月分, 12 times the monthly premium, 12 monthly payments). */
+export const phrasesIn = (text: string, words: PeriodMultipleWords): Phrase[] => {
+  const bases = occurrences(text, words.bases);
+  return countsIn(text, words).flatMap((count) => {
+    const base = baseOf(text, count, bases, words);
+    if (base === undefined || endsRange(text, count, words)) return [];
+    return [{ start: Math.min(base.start, count.start), end: Math.max(base.end, count.end), count: count.count }];
+  });
+};
+
+const amountsWithin = (amounts: readonly StatedAmount[], span: Span): StatedAmount[] =>
+  amounts.filter((amount) => amount.offset >= span.start && amount.end <= span.end);
+
+const inside = (phrases: readonly Phrase[], offset: number): boolean => phrases.some((phrase) => offset >= phrase.start && offset < phrase.end);
+
+/** A base label followed on its line by an amount (月払 | 2,400円, Monthly: $24); unclear when the sentence holds more. */
+const baseAt = (text: string, label: Span, amounts: readonly StatedAmount[], phrases: readonly Phrase[], words: PeriodMultipleWords): Base[] => {
+  const sentence = sentenceAround(text, label);
+  const [first, ...rest] = amountsWithin(amounts, { start: label.end, end: sentence.end });
+  if (first === undefined || !isPlainGap(text.slice(label.end, first.offset), words.links)) return [];
+  const written = text.slice(first.offset, first.end);
+  const statement = text.slice(sentence.start, sentence.end);
+  const unclear =
+    rest.length > 0 || occurrences(statement, words.skips).length > 0 || phrases.some((phrase) => phrase.start >= sentence.start && phrase.end <= sentence.end);
+  const range = unclear ? undefined : intervalOf(first, written);
+  return [{ offset: label.start, label: text.slice(label.start, label.end), currency: first.currency, range, written }];
+};
+
+/** Each base label outside a multiple that is followed by its amount, in document order. */
+const statedBases = (text: string, amounts: readonly StatedAmount[], phrases: readonly Phrase[], words: PeriodMultipleWords): Base[] =>
+  occurrences(text, words.bases)
+    .filter((label) => !inside(phrases, label.start))
+    .flatMap((label) => baseAt(text, label, amounts, phrases, words));
+
+const gapBetween = (text: string, phrase: Phrase, amount: StatedAmount): string =>
+  amount.offset >= phrase.end ? text.slice(phrase.end, amount.offset) : text.slice(amount.end, phrase.start);
+
+/** The one amount a phrase's sentence states beside it, when the sentence holds no other amount, phrase or skip word. */
+const multipleAmount = (
+  text: string,
+  phrase: Phrase,
+  phrases: readonly Phrase[],
+  amounts: readonly StatedAmount[],
+  words: PeriodMultipleWords,
+): StatedAmount | undefined => {
+  const sentence = sentenceAround(text, phrase);
+  const [amount, ...rest] = amountsWithin(amounts, sentence);
+  if (amount === undefined || rest.length > 0 || (amount.offset < phrase.end && amount.end > phrase.start)) return undefined;
+  const others = phrases.some((other) => other !== phrase && other.start >= sentence.start && other.end <= sentence.end);
+  if (others || occurrences(text.slice(sentence.start, sentence.end), words.skips).length > 0) return undefined;
+  return MARKS_ONLY.test(gapBetween(text, phrase, amount)) ? amount : undefined;
+};
+
+const mismatchOf = (
+  text: string,
+  phrase: Phrase,
+  phrases: readonly Phrase[],
+  amounts: readonly StatedAmount[],
+  bases: readonly Base[],
+  words: PeriodMultipleWords,
+): StructureIssue[] => {
+  const amount = multipleAmount(text, phrase, phrases, amounts, words);
+  const base = nearestStated(bases, phrase.start);
+  if (amount === undefined || base?.range === undefined || base.currency !== amount.currency) return [];
+  if (isMultiple(phrase.count, intervalOf(amount, text.slice(amount.offset, amount.end)), [base.range])) return [];
+  const values = {
+    multiple: text.slice(phrase.start, phrase.end),
+    amount: text.slice(amount.offset, amount.end),
+    label: base.label,
+    base: base.written,
+    count: phrase.count,
+  };
+  return [{ offset: Math.min(phrase.start, amount.offset), values }];
+};
+
+/** Every amount stated as a number of a base's amount (月払の12か月分) that is not that many of the nearest stated base. */
+export const periodMultipleMismatches = (text: string, amounts: readonly StatedAmount[], words: PeriodMultipleWords): StructureIssue[] => {
+  const phrases = phrasesIn(text, words);
+  if (phrases.length === 0) return [];
+  const bases = statedBases(text, amounts, phrases, words);
+  return phrases.flatMap((phrase) => mismatchOf(text, phrase, phrases, amounts, bases, words));
+};

package/src/structure/quantity-range.ts

@@ -0,0 +1,47 @@
+// quantity-range-reversed: which measured quantities may be one end of a range, read as the ends structure/amount-range.ts
+// compares. Pure.
+import type { Measured } from "../facts/measures.ts";
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+import type { RangeAmount } from "./amount-range.ts";
+
+/** 10 and a minus sign right before the number is a power of ten written flat ("10-8 cm" for 10⁻⁸ cm), not a range. */
+const POWER_OF_TEN = /(?<![0-9０-９.,，．])[1１][0０][-−－]$/u;
+
+/** "10-" and the character before it, which must not be a digit (110-8 cm is a range). */
+const POWER_OF_TEN_LOOKBACK = 4;
+
+const isExponent = (text: string, measured: Measured): boolean =>
+  POWER_OF_TEN.test(text.slice(Math.max(0, measured.start - POWER_OF_TEN_LOOKBACK), measured.start));
+
+/** A quantity as one end of a range: two ends compare only in one unit, however it is spelled (℃ with °C, m with meters). */
+const rangeEndOf = (text: string, measured: Measured): RangeAmount => ({
+  offset: measured.start,
+  end: measured.end,
+  currency: `${measured.dimension}:${measured.factors.join(",")}`,
+  value: measured.amount,
+  scale: undefined,
+  position: text.startsWith(measured.unit, measured.start) ? "before" : "after",
+});
+
+/** The measured quantities that can end a range, as range ends. */
+export const quantityRangeEnds = (text: string, measured: readonly Measured[]): RangeAmount[] =>
+  measured.filter((value) => !isExponent(text, value)).map((value) => rangeEndOf(text, value));
+
+const LATIN_WORD = /^[A-Za-z]/u;
+
+/** Whether a lead word stands right before the range on its line ("went from 9 minutes to 2 minutes" tells of a change). */
+const ledBy = (text: string, offset: number, leads: readonly string[]): boolean => {
+  const before = text
+    .slice(text.lastIndexOf("\n", offset - 1) + 1, offset)
+    .trimEnd()
+    .toLowerCase();
+  return leads.some((lead) => {
+    const edge = LATIN_WORD.test(lead) ? "(?<![a-z])" : "";
+    return new RegExp(`${edge}${escapeRegExp(lead.toLowerCase())}$`, "u").test(before);
+  });
+};
+
+/** The reversed ranges that no lead word frames as a change. */
+export const unledRanges = (text: string, issues: readonly StructureIssue[], leads: readonly string[]): StructureIssue[] =>
+  issues.filter((issue) => !ledBy(text, issue.offset, leads));