chaffjs 0.29.0 → 0.31.0

package/src/structure/rent-multiple.ts

@@ -0,0 +1,277 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * rent-multiple-mismatch: a deposit, key money or guarantee given both as a number of months of rent and as an amount that
+ * is not that many months of the listing's rent (敷金 2か月（98,000円） with 賃料 98,000円; "Deposit: Six months' rent
+ * ($145,000)" with Rent $21,500). The rent is the nearest one stated before the deposit (several listings on one page each
+ * state their own); a document whose deposits come before any rent uses the rent only when it states one. When the document
+ * also states a fee beside the rent (管理費, service charge), the multiple may be of the rent alone or of the rent and the
+ * fee, since listings do both and seldom say which. A months count without an amount, an amount without a months count, a
+ * range of months, and two different pairs in one statement are not compared. The words come from the lexicons. Pure.
+ */
+
+/** One amount of money as read: its currency, its value, and the value of the word of scale written in it (万), if any. */
+export type RentAmount = {
+  readonly offset: number;
+  readonly end: number;
+  readonly currency: string;
+  readonly value: number;
+  readonly scale: number | undefined;
+};
+
+export type RentMultipleWords = {
+  /** Labels of the monthly rent (賃料, Rent). */
+  readonly rents: readonly string[];
+  /** Labels of a monthly fee paid with the rent (管理費, Service charge). */
+  readonly fees: readonly string[];
+  /** Labels of an amount stated in months of rent (敷金, 礼金, Security deposit). */
+  readonly multiples: readonly string[];
+  /** The word of a month after a count (か月, months). */
+  readonly months: readonly string[];
+  /** Words that may stand between a label or a months count and its amount (は, 分, of, equal to). */
+  readonly links: readonly string[];
+  /** Words that say an amount is not per month (per week, 年額, per sq ft); a rent line with one is not read. */
+  readonly periods: readonly string[];
+  /** Words that make the amount something other than the plain multiple (税込, tax included). */
+  readonly skips: readonly string[];
+  /** Marks and words that join the two ends of a range (〜, to). */
+  readonly connectors: readonly string[];
+  /** Numbers written as words (six, 一) and their values. */
+  readonly numberWords: readonly { readonly word: string; readonly value: number }[];
+};
+
+/** An amount read as the interval its written digits allow (9.8万円 is anything from 97,500 to 98,500). */
+export type Interval = { readonly low: number; readonly high: number };
+
+/** A rent or fee as stated. range is undefined when the label has amounts that are not one monthly amount (a change, per week). */
+type Stated = { readonly offset: number; readonly currency: string; readonly range: Interval | undefined; readonly written: string };
+
+type Months = { readonly start: number; readonly end: number; readonly count: number };
+
+/** Rounding to the currency's unit (a yen, a dollar) is allowed on top of the written precision. */
+const UNIT_SLACK = 1;
+
+const LATIN = /[A-Za-z]/u;
+const SEPARATORS = /[\s|｜:：=＝、，,・/／'’()（）[\]［］-]/gu;
+const PARENTHETICAL_WITHOUT_DIGITS = /[（(][^()（）0-9０-９]*[)）]/gu;
+/** The possessive after a months count (2 months' rent, 1 month's rent). */
+const POSSESSIVE = /['’]s?(?![A-Za-z])/gu;
+const RANGE_START = /[0-9０-９A-Za-z一二三四五六七八九十]\s*$/u;
+const SENTENCE_END = /[。！？；;]|[.!?](?=\s|$)/u;
+const DIGITS = "[0-9０-９]+(?:[.．][0-9０-９]+)?";
+
+const wordPattern = (word: string): string => {
+  const edgeStart = LATIN.test(word.charAt(0)) ? "(?<![A-Za-z])" : "";
+  const edgeEnd = LATIN.test(word.charAt(word.length - 1)) ? "(?![A-Za-z])" : "";
+  return `${edgeStart}${escapeRegExp(word)}${edgeEnd}`;
+};
+
+/** One alternation of the words, longest first so 月額賃料 wins over 賃料. Undefined when there are none. */
+const alternation = (words: readonly string[]): string | undefined =>
+  words.length === 0
+    ? undefined
+    : words
+        .toSorted((left, right) => right.length - left.length)
+        .map(wordPattern)
+        .join("|");
+
+const occurrences = (text: string, words: readonly string[]): { readonly start: number; readonly end: number }[] => {
+  const pattern = alternation(words);
+  if (pattern === undefined) return [];
+  return [...text.matchAll(new RegExp(pattern, "giu"))].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const withoutWords = (text: string, words: readonly string[]): string => {
+  const pattern = alternation(words);
+  return pattern === undefined ? text : text.replace(new RegExp(pattern, "giu"), "");
+};
+
+/** Whether only separators, bracketed words and link words stand in the gap (「 | 」, " (monthly): ", "の", "'s rent ("). */
+export const isPlainGap = (gap: string, words: readonly string[]): boolean =>
+  withoutWords(gap.replace(PARENTHETICAL_WITHOUT_DIGITS, "").replace(POSSESSIVE, ""), words).replace(SEPARATORS, "") === "";
+
+const decimalsOf = (written: string): number => /[.．]([0-9０-９]+)/u.exec(written)?.[1]?.length ?? 0;
+
+/** The interval an amount's digits allow: a word of scale (9.8万) leaves half its last digit either way; plain digits are exact. */
+export const intervalOf = (amount: RentAmount, written: string): Interval => {
+  const half = amount.scale === undefined ? 0 : (amount.scale * 10 ** -decimalsOf(written)) / 2;
+  return { low: amount.value - half, high: amount.value + half };
+};
+
+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 };
+};
+
+const amountsBetween = (amounts: readonly RentAmount[], start: number, end: number): RentAmount[] =>
+  amounts.filter((amount) => amount.offset >= start && amount.end <= end);
+
+/** A label preceded by a months count (2 months' rent, First month's rent) names a multiple, not the rent. */
+const followsMonths = (before: string, words: RentMultipleWords): boolean => {
+  const trimmed = before.replace(/['’]s?\s*$/u, "").trimEnd();
+  return words.months.some((month) => trimmed.toLowerCase().endsWith(month.toLowerCase()));
+};
+
+/** The second end of a range that starts with this amount (85,000円〜90,000円), if one follows. */
+const rangeEnd = (text: string, first: RentAmount, next: RentAmount | undefined, words: RentMultipleWords): RentAmount | undefined => {
+  if (next === undefined || next.currency !== first.currency || next.value < first.value) return undefined;
+  const joint = text.slice(first.end, next.offset).trim();
+  return words.connectors.some((connector) => connector.toLowerCase() === joint.toLowerCase()) ? next : undefined;
+};
+
+/** Where a label's own amount must be: before the next label of any kind on its line (賃料 98,000円 管理費 6,000円). */
+const labelledEnd = (text: string, from: number, lineEnd: number, words: RentMultipleWords): number => {
+  const [next] = occurrences(text.slice(from, lineEnd), [...words.rents, ...words.fees, ...words.multiples]);
+  return next === undefined ? lineEnd : from + next.start;
+};
+
+/**
+ * A rent or fee stated with one amount or one range of amounts. With a second amount (a change from one to another, two
+ * units) or a word of another period on the line (per week, 年額), it is stated but its monthly amount is not known.
+ */
+const statedAt = (
+  text: string,
+  label: { readonly start: number; readonly end: number },
+  amounts: readonly RentAmount[],
+  words: RentMultipleWords,
+): Stated[] => {
+  const line = lineBounds(text, label.start);
+  const [first, second, ...rest] = amountsBetween(amounts, label.end, labelledEnd(text, label.end, line.end, words));
+  if (first === undefined || !isPlainGap(text.slice(label.end, first.offset), words.links)) return [];
+  if (followsMonths(text.slice(line.start, label.start), words)) return [];
+  const last = rangeEnd(text, first, second, words) ?? first;
+  const written = text.slice(first.offset, last.end);
+  const unclear = (second !== undefined && last !== second) || rest.length > 0 || occurrences(text.slice(line.start, line.end), words.periods).length > 0;
+  if (unclear) return [{ offset: label.start, currency: first.currency, range: undefined, written }];
+  const range = { low: intervalOf(first, text.slice(first.offset, first.end)).low, high: intervalOf(last, text.slice(last.offset, last.end)).high };
+  return [{ offset: label.start, currency: first.currency, range, written }];
+};
+
+/** Each label of the kind followed on its line by an amount (賃料 | 98,000円, Rent: $1,600 to $1,700), in document order. */
+const statedAmounts = (text: string, labels: readonly string[], amounts: readonly RentAmount[], words: RentMultipleWords): Stated[] =>
+  occurrences(text, labels).flatMap((label) => statedAt(text, label, amounts, words));
+
+const numberWordValue = (word: string, words: RentMultipleWords): number | undefined =>
+  words.numberWords.find((entry) => entry.word.toLowerCase() === word.toLowerCase())?.value;
+
+const countOf = (written: string, words: RentMultipleWords): number => numberWordValue(written, words) ?? Number(written.normalize("NFKC"));
+
+/** The months counts in a piece of text (2か月, Six months), with the offset of the piece. */
+export const monthsIn = (piece: string, offset: number, words: RentMultipleWords): Months[] => {
+  const marker = alternation(words.months);
+  if (marker === undefined) return [];
+  const numberWords = alternation(words.numberWords.map((entry) => entry.word));
+  const count = numberWords === undefined ? DIGITS : `${DIGITS}|${numberWords}`;
+  const pattern = new RegExp(`(?<![0-9０-９.,，．])(${count})\\s?(?:${marker})`, "giu");
+  return [...piece.matchAll(pattern)].map((match) => ({
+    start: offset + match.index,
+    end: offset + match.index + match[0].length,
+    count: countOf(match[1] ?? "", words),
+  }));
+};
+
+/** Whether a months count is the upper end of a range (1〜2か月). */
+const endsRange = (text: string, months: Months, words: RentMultipleWords): boolean => {
+  const before = text.slice(Math.max(0, months.start - 12), months.start).trimEnd();
+  return words.connectors.some((connector) => before.endsWith(connector) && RANGE_START.test(before.slice(0, -connector.length)));
+};
+
+type Pair = { readonly months: Months; readonly amount: RentAmount };
+
+const gapBetween = (text: string, months: Months, amount: RentAmount): string =>
+  amount.offset >= months.end ? text.slice(months.end, amount.offset) : text.slice(amount.end, months.start);
+
+/** A months count and an amount standing together, either way round (1か月（98,000円）, $3,200 (2 months' rent)). */
+const pairsIn = (text: string, months: readonly Months[], amounts: readonly RentAmount[], words: RentMultipleWords): Pair[] => {
+  const between = [...words.links, ...words.rents];
+  return months.flatMap((count) =>
+    amounts
+      .filter((amount) => (amount.offset >= count.end || amount.end <= count.start) && isPlainGap(gapBetween(text, count, amount), between))
+      .map((amount) => ({ months: count, amount })),
+  );
+};
+
+type Statement = { readonly label: number; readonly pair: Pair };
+
+/** Where the statement of one label ends: at the next label of its kind, the end of the sentence, or the end of the line. */
+const statementEnd = (text: string, from: number, nextLabel: number | undefined): number => {
+  const line = lineBounds(text, from);
+  const sentence = SENTENCE_END.exec(text.slice(from, line.end));
+  return Math.min(line.end, nextLabel ?? line.end, sentence === null ? line.end : from + sentence.index);
+};
+
+/** One label's months count and amount, when the statement holds exactly one such pair and no word that makes it another. */
+const statementAt = (
+  text: string,
+  label: { readonly start: number; readonly end: number },
+  next: number | undefined,
+  amounts: readonly RentAmount[],
+  words: RentMultipleWords,
+): Statement[] => {
+  const end = statementEnd(text, label.end, next);
+  const piece = text.slice(label.end, end);
+  if (occurrences(piece, words.skips).length > 0) return [];
+  const months = monthsIn(piece, label.end, words);
+  if (months.some((count) => endsRange(text, count, words))) return [];
+  const pairs = pairsIn(text, months, amountsBetween(amounts, label.end, end), words);
+  const [pair] = pairs;
+  const single = pairs.every((other) => other.months.count === pair?.months.count && other.amount.value === pair.amount.value);
+  return pair === undefined || !single ? [] : [{ label: label.start, pair }];
+};
+
+/** Every label of a multiple with one months count and one amount (敷金 | 2か月（98,000円）). */
+const multipleStatements = (text: string, amounts: readonly RentAmount[], words: RentMultipleWords): Statement[] => {
+  const labels = occurrences(text, words.multiples);
+  return labels.flatMap((label, index) => statementAt(text, label, labels[index + 1]?.start, amounts, words));
+};
+
+/** The rent a statement at this offset is of: the nearest before it, or, before any, the one rent the document states. */
+export const rentFor = <T extends Stated>(rents: readonly T[], offset: number): T | undefined => {
+  const before = rents.filter((rent) => rent.offset < offset).at(-1);
+  if (before !== undefined) return before;
+  const [first] = rents;
+  return rents.every((rent) => rent.range !== undefined && rent.range.low === first?.range?.low && rent.range.high === first.range.high) ? first : undefined;
+};
+
+/** The fees of the listing a rent belongs to: those after it and before the next rent; for the first rent, else those before it. */
+export const feesFor = <T extends Stated>(rent: Stated, rents: readonly Stated[], fees: readonly T[]): T[] => {
+  const index = rents.indexOf(rent);
+  const next = rents[index + 1]?.offset ?? Number.POSITIVE_INFINITY;
+  const ofCurrency = fees.filter((fee) => fee.currency === rent.currency);
+  const after = ofCurrency.filter((fee) => fee.offset > rent.offset && fee.offset < next);
+  return after.length > 0 || index > 0 ? after : ofCurrency.filter((fee) => fee.offset < rent.offset);
+};
+
+const plus = (left: Interval, right: Interval): Interval => ({ low: left.low + right.low, high: left.high + right.high });
+
+/** The monthly amounts a multiple may be of: the rent alone, the rent with each fee, and the rent with every fee. */
+export const monthlyBases = (rent: Interval, fees: readonly Interval[]): Interval[] => {
+  const withEach = fees.map((fee) => plus(rent, fee));
+  const withAll = fees.length > 1 ? [fees.reduce(plus, rent)] : [];
+  return [rent, ...withEach, ...withAll];
+};
+
+/** Whether the amount is the count of months of one of the bases, within the written precision and a unit's rounding. */
+export const isMultiple = (count: number, amount: Interval, bases: readonly Interval[]): boolean =>
+  bases.some((base) => count * base.low - UNIT_SLACK <= amount.high && amount.low <= count * base.high + UNIT_SLACK);
+
+const mismatchOf = (text: string, statement: Statement, rents: readonly Stated[], fees: readonly Stated[]): StructureIssue[] => {
+  const rent = rentFor(rents, statement.label);
+  const { months, amount } = statement.pair;
+  if (rent?.range === undefined || rent.currency !== amount.currency) return [];
+  const feeRanges = feesFor(rent, rents, fees).map((fee) => fee.range);
+  if (!feeRanges.every((range) => range !== undefined)) return [];
+  const bases = monthlyBases(rent.range, feeRanges);
+  if (isMultiple(months.count, intervalOf(amount, text.slice(amount.offset, amount.end)), bases)) return [];
+  const values = { months: text.slice(months.start, months.end), amount: text.slice(amount.offset, amount.end), rent: rent.written };
+  return [{ offset: Math.min(months.start, amount.offset), values }];
+};
+
+/** Every multiple of rent whose amount is not that many months of the listing's rent (or of the rent and its fee). */
+export const rentMultipleMismatches = (text: string, amounts: readonly RentAmount[], words: RentMultipleWords): StructureIssue[] => {
+  const rents = statedAmounts(text, words.rents, amounts, words);
+  if (rents.length === 0) return [];
+  const fees = statedAmounts(text, words.fees, amounts, words);
+  return multipleStatements(text, amounts, words).flatMap((statement) => mismatchOf(text, statement, rents, fees));
+};

package/src/structure/requirement-lists.ts

@@ -0,0 +1,145 @@
+// required-listed-as-preferred: one skill or qualification listed under a required heading or label and again under a
+// preferred one. The headings and labels, the units and words of a length of experience, and the words that only end an
+// item come from the lexicons. Pure.
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/** A heading, a line standing alone (a label if it is one of the words), or one list item, in document order. */
+export type RequirementBlock =
+  | { readonly kind: "heading"; readonly depth: number; readonly text: string; readonly offset: number }
+  | { readonly kind: "line"; readonly text: string; readonly offset: number }
+  | { readonly kind: "item"; readonly text: string; readonly offset: number };
+
+export type ValuedWord = { readonly word: string; readonly value: number };
+
+export type RequirementWords = {
+  /** Headings and labels of what an applicant must have (必須, Required) and of what is welcome (歓迎, Preferred). */
+  readonly required: readonly string[];
+  readonly preferred: readonly string[];
+  /** Units of a length of experience, valued in months (年 12, month 1). */
+  readonly units: readonly ValuedWord[];
+  /** Words that stand before or after a length and belong to it (at least, 以上, of). */
+  readonly before: readonly string[];
+  readonly after: readonly string[];
+  /** Numbers written as words (three, 三). */
+  readonly numbers: readonly ValuedWord[];
+  /** Words that only end an item and are not the skill (の方, こと). */
+  readonly endings: readonly string[];
+};
+
+type Kind = "required" | "preferred";
+
+/** container is the offset of the heading holding the lists (a posting, 応募の条件), -1 for none; only one container's items are compared. */
+type Requirement = { readonly kind: Kind; readonly text: string; readonly offset: number; readonly container: number };
+
+/** The skill an item names with its length of experience taken out, and that length in months (0 when none). */
+type Reading = { readonly core: string; readonly months: number };
+
+const MARKS = /[*_`~]/gu;
+
+const LATIN = /^[a-z]/u;
+
+const plain = (text: string): string => text.normalize("NFKC").toLowerCase().replace(MARKS, "").replace(/\s+/gu, " ").trim();
+
+/** A Latin word is matched at word edges; other scripts as written. */
+const wordPattern = (word: string): string => {
+  const escaped = escapeRegExp(plain(word));
+  return LATIN.test(plain(word)) ? `(?<![a-z])${escaped}(?![a-z])` : escaped;
+};
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .toSorted((left, right) => right.length - left.length)
+    .map(wordPattern)
+    .join("|");
+
+/** The text without the characters at either end that the test accepts (no backtracking regex on long lines). */
+const trimWhere = (text: string, isEdge: (char: string) => boolean): string => {
+  const chars = [...text];
+  const start = chars.findIndex((char) => !isEdge(char));
+  return start === -1 ? "" : chars.slice(start, chars.findLastIndex((char) => !isEdge(char)) + 1).join("");
+};
+
+const LABEL_EDGE = /[\s【［[「(（】］\]」)）:：]/u;
+
+const asLabel = (text: string): string => trimWhere(plain(text).replace(/[-‐–]/gu, " "), (char) => LABEL_EDGE.test(char)).replace(/\s+/gu, " ");
+
+const kindOfLabel = (label: string, words: RequirementWords): Kind | undefined => {
+  if (label === "") return undefined;
+  if (words.required.some((word) => asLabel(word) === label)) return "required";
+  return words.preferred.some((word) => asLabel(word) === label) ? "preferred" : undefined;
+};
+
+const HEADING_PARTS = /[・/／、,，(（:：]/u;
+
+/** A heading names its kind by its first part (必須スキル・経験, 歓迎（あれば尚可）); a line standing alone, by all of it. */
+const kindOfHeading = (text: string, words: RequirementWords): Kind | undefined => kindOfLabel(asLabel(text.split(HEADING_PARTS)[0] ?? ""), words);
+
+type Scope = { readonly depth: number; readonly kind: Kind | undefined; readonly offset: number };
+
+type Walk = { readonly scopes: readonly Scope[]; readonly label: Kind | undefined; readonly items: readonly Requirement[] };
+
+/** A heading opens a scope that its subheadings inherit unless they name their own kind; a label holds until the next heading or label. */
+const step = (walk: Walk, block: RequirementBlock, words: RequirementWords): Walk => {
+  if (block.kind === "heading") {
+    const outer = walk.scopes.filter((scope) => scope.depth < block.depth);
+    const kind = kindOfHeading(block.text, words) ?? outer.at(-1)?.kind;
+    return { ...walk, scopes: [...outer, { depth: block.depth, kind, offset: block.offset }], label: undefined };
+  }
+  if (block.kind === "line") {
+    const kind = kindOfLabel(asLabel(block.text), words);
+    return kind === undefined ? walk : { ...walk, label: kind };
+  }
+  const kind = walk.label ?? walk.scopes.at(-1)?.kind;
+  const container = walk.scopes.findLast((scope) => scope.kind === undefined)?.offset ?? -1;
+  return kind === undefined ? walk : { ...walk, items: [...walk.items, { kind, text: block.text.trim(), offset: block.offset, container }] };
+};
+
+const numberPattern = (words: RequirementWords): string =>
+  [String.raw`\d+(?:\.\d+)?`, alternation(words.numbers.map((entry) => entry.word))].filter((part) => part !== "").join("|");
+
+const lengthPattern = (words: RequirementWords): RegExp | undefined => {
+  if (words.units.length === 0) return undefined;
+  const before = words.before.length === 0 ? "" : `(?:(?:${alternation(words.before)})\\s*)?`;
+  const after = words.after.length === 0 ? "" : `(?:\\s*(?:${alternation(words.after)}))*`;
+  return new RegExp(`${before}(${numberPattern(words)})\\s*\\+?\\s*(${alternation(words.units.map((unit) => unit.word))})['’]?${after}`, "gu");
+};
+
+const valueOf = (written: string, words: readonly ValuedWord[]): number => words.find((entry) => plain(entry.word) === written)?.value ?? Number(written);
+
+/** Punctuation, symbols and spaces, but not the + and # that end a name (C++, C#). */
+const PUNCTUATION = /(?<![\p{L}\p{N}+#])[+#]|[^\p{L}\p{N}+#]/gu;
+
+const EDGE_PUNCTUATION = /[\p{P}\s]/u;
+
+const withoutEnding = (written: string, endings: readonly string[]): string => {
+  const text = trimWhere(written, (char) => char !== "#" && EDGE_PUNCTUATION.test(char));
+  const ending = endings.map(plain).find((word) => word !== "" && text.endsWith(word) && text.length > word.length);
+  return ending === undefined ? text : withoutEnding(text.slice(0, -ending.length), endings);
+};
+
+const readingOf = (text: string, words: RequirementWords): Reading => {
+  const written = plain(text);
+  const pattern = lengthPattern(words);
+  const lengths = pattern === undefined ? [] : [...written.matchAll(pattern)];
+  const months = lengths.map((match) => valueOf(match[1] ?? "", words.numbers) * (words.units.find((unit) => plain(unit.word) === match[2])?.value ?? 0));
+  const rest = pattern === undefined ? written : written.replace(pattern, " ");
+  return { core: withoutEnding(rest.replace(/\s+/gu, " ").trim(), words.endings).replace(PUNCTUATION, ""), months: Math.max(0, ...months) };
+};
+
+/** A preferred item repeats a required one when it names the same skill and asks for no longer experience. */
+const repeats = (preferred: Reading, required: Reading): boolean =>
+  preferred.core !== "" && preferred.core === required.core && preferred.months <= required.months;
+
+/** The preferred items that repeat a required item of the same document, once each, in document order. */
+export const requiredListedAsPreferred = (blocks: readonly RequirementBlock[], words: RequirementWords): StructureIssue[] => {
+  const { items } = blocks.reduce<Walk>((walk, block) => step(walk, block, words), { scopes: [], label: undefined, items: [] });
+  const required = items.filter((item) => item.kind === "required").map((item) => ({ item, reading: readingOf(item.text, words) }));
+  return items
+    .filter((item) => item.kind === "preferred")
+    .flatMap((item) => {
+      const reading = readingOf(item.text, words);
+      const match = required.find((candidate) => candidate.item.container === item.container && repeats(reading, candidate.reading));
+      return match === undefined ? [] : [{ offset: item.offset, values: { item: item.text, required: match.item.text } }];
+    });
+};

package/src/structure/scaled-quantities.ts

@@ -0,0 +1,225 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { measuredValues, type MeasureUnit } from "../facts/measures.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "./lines.ts";
+import type { Mark } from "./time-marks.ts";
+
+/**
+ * A table with one column per number of servings or batch size (4人分 / 8人分, Serves 4 / Serves 8, ×1 / ×2), and the one
+ * row that does not grow by the columns' ratio while the others do. The words come from the language packages. Pure.
+ */
+export type ScaleWords = {
+  /** What marks a column as a number of servings (人分 after the number, Serves before it). */
+  readonly columns: readonly Mark[];
+  /** An amount that is left to the cook (少々, to taste): its row may stay as it is. */
+  readonly unscaled: readonly string[];
+  /** Spellings of one unit (teaspoon, teaspoons, tsp), each named by its group. */
+  readonly unitForms: readonly { readonly pattern: string; readonly group: string }[];
+  /** Units with a factor to a base unit (g and kg), so 1 kg and 1000 g read as one amount. */
+  readonly measures: readonly MeasureUnit[];
+};
+
+/** amount is in the base unit when the unit has a factor (1 kg is 1000); written is the number as written (1). */
+export type Amount = { readonly amount: number; readonly written: number; readonly unit: string };
+
+export type ScaleSlip = {
+  /** The row's first cell: the item. */
+  readonly item: Cell;
+  /** The cell that does not scale, and the column it is in. */
+  readonly cell: Cell;
+  readonly heading: string;
+  /** The cell it is compared with, and that column. */
+  readonly other: Cell;
+  readonly otherHeading: string;
+  /** What the cell would hold if it scaled like the other rows, in the unit it is written in. */
+  readonly expected: number;
+  readonly scaledRows: number;
+};
+
+/** Fewer rows than this that scale exactly are no evidence that the table scales at all. */
+export const MIN_SCALED_ROWS = 3;
+const SAME = 1e-9;
+const MIN_COLUMNS = 2;
+
+const NUMBER_TEXT = "[0-9]+(?:\\.[0-9]+)?";
+
+/** The number of servings a column heading names (4人分, Serves 8, ×2), or undefined. */
+export const servingsOf = (heading: string, marks: readonly Mark[]): number | undefined => {
+  const text = withoutEdgeMarks(heading.normalize("NFKC").trim()).toLowerCase();
+  const read = marks
+    .map((mark) => {
+      const word = escapeRegExp(mark.pattern.normalize("NFKC").toLowerCase());
+      const pattern = mark.position === "before" ? `^${word}\\s*(${NUMBER_TEXT})$` : `^(${NUMBER_TEXT})\\s*${word}$`;
+      return new RegExp(pattern, "u").exec(text)?.[1];
+    })
+    .find((number) => number !== undefined);
+  const servings = read === undefined ? undefined : Number(read);
+  return servings === undefined || !Number.isFinite(servings) || servings <= 0 ? undefined : servings;
+};
+
+/** A whole or decimal number (1,000 and 1.5), with a fraction after it (1 1/2) or as a fraction (1/2, ½). */
+const WHOLE = String.raw`[0-9]+(?:,[0-9]{3})*(?:\.[0-9]+)?`;
+const FRACTION = String.raw`(?:\s([0-9]+)[/⁄]([0-9]+)|[/⁄]([0-9]+))?`;
+const AMOUNT = new RegExp(String.raw`(?<![\p{N}.,/⁄])(${WHOLE})${FRACTION}(?![\p{N}/⁄])`, "gu");
+
+const valueOf = (match: RegExpMatchArray): number => {
+  const whole = Number((match[1] ?? "").replace(/,/gu, ""));
+  if (match[4] !== undefined) return whole / Number(match[4]);
+  return match[2] === undefined ? whole : whole + Number(match[2]) / Number(match[3]);
+};
+
+const LETTER_BEFORE = "(?<!\\p{L})";
+const LETTER_AFTER = "(?!\\p{L})";
+
+/** The cell's text with its number taken out and each spelling of a unit written as its group: "2 teaspoons" is "#teaspoon". */
+const unitKey = (text: string, numberAt: Span, forms: ScaleWords["unitForms"]): string => {
+  const rest = `${text.slice(0, numberAt.start)}#${text.slice(numberAt.end)}`.toLowerCase();
+  const groups = new Map(forms.map((form) => [form.pattern.toLowerCase(), form.group]));
+  const spellings = [...groups.keys()].filter((pattern) => pattern !== "").toSorted((left, right) => right.length - left.length);
+  const grouped =
+    spellings.length === 0
+      ? rest
+      : rest.replace(
+          new RegExp(`${LETTER_BEFORE}(?:${spellings.map(escapeRegExp).join("|")})${LETTER_AFTER}`, "gu"),
+          (spelling) => `<${groups.get(spelling) ?? spelling}>`,
+        );
+  return grouped.replace(/\s+/gu, "");
+};
+
+/** NFKC writes ½ as 1⁄2, so 1½ would read as 11⁄2: a space keeps the whole number apart (1 1⁄2). */
+const VULGAR_AFTER_DIGIT = /([0-9０-９])([¼½¾⅐-⅞])/gu;
+
+const normalized = (cellText: string): string => withoutEdgeMarks(cellText.replace(VULGAR_AFTER_DIGIT, "$1 $2").normalize("NFKC").trim());
+
+/** One cell's amount and the unit it is in. undefined when the cell holds no number, or more than one (1と1/2, 2 (300 g)). */
+export const amountOf = (cellText: string, words: ScaleWords): Amount | undefined => {
+  const text = normalized(cellText);
+  const numbers = [...text.matchAll(AMOUNT)];
+  const [only] = numbers;
+  if (numbers.length !== 1 || only === undefined) return undefined;
+  const written = valueOf(only);
+  if (!Number.isFinite(written)) return undefined;
+  const [measured] = measuredValues(text, words.measures);
+  const factor = measured?.factors[0];
+  if (measured !== undefined && factor !== undefined && measured.start === only.index && measured.end === text.length) {
+    return { amount: measured.amount * factor, written: measured.amount, unit: `=${measured.dimension}` };
+  }
+  return { amount: written, written, unit: unitKey(text, { start: only.index, end: only.index + only[0].length }, words.unitForms) };
+};
+
+const isUnscaled = (text: string, unscaled: readonly string[]): boolean => {
+  const lower = text.normalize("NFKC").toLowerCase();
+  return unscaled.some((word) => word !== "" && lower.includes(word.normalize("NFKC").toLowerCase()));
+};
+
+type Column = { readonly index: number; readonly servings: number; readonly heading: string };
+
+type Row = { readonly item: Cell; readonly cells: readonly Cell[] };
+
+/** The rows of one table whose item is named, as cells. */
+const rowsOf = (rows: readonly Line[]): Row[] =>
+  rows.flatMap((line) => {
+    const cells = cellsOf(line);
+    const [item] = cells;
+    return item === undefined || withoutEdgeMarks(item.text) === "" ? [] : [{ item, cells }];
+  });
+
+type Pair = {
+  readonly row: Row;
+  readonly baseCell: Cell;
+  readonly cell: Cell;
+  readonly from: Amount;
+  readonly to: Amount;
+  readonly scales: boolean;
+};
+
+/** Each row's two cells, when both are amounts in one unit and the row is not left to the cook. */
+const readablePairs = (rows: readonly Row[], base: Column, other: Column, words: ScaleWords): Pair[] =>
+  rows.flatMap((row): Pair[] => {
+    const [baseCell, cell] = [row.cells[base.index], row.cells[other.index]];
+    if (baseCell === undefined || cell === undefined) return [];
+    if (isUnscaled(baseCell.text, words.unscaled) || isUnscaled(cell.text, words.unscaled)) return [];
+    const [from, to] = [amountOf(baseCell.text, words), amountOf(cell.text, words)];
+    if (from === undefined || to === undefined || from.unit !== to.unit) return [];
+    const scaled = (from.amount * other.servings) / base.servings;
+    return [{ row, baseCell, cell, from, to, scales: Math.abs(to.amount - scaled) <= SAME * Math.max(Math.abs(scaled), 1) }];
+  });
+
+type Departure = { readonly pair: Pair; readonly scaled: number };
+
+/** The one row of a column that departs from the base column while at least MIN_SCALED_ROWS others scale exactly. */
+const departureOf = (rows: readonly Row[], base: Column, other: Column, words: ScaleWords): Departure | undefined => {
+  const pairs = readablePairs(rows, base, other, words);
+  const departing = pairs.filter((pair) => !pair.scales);
+  const [only] = departing;
+  const scaled = pairs.length - departing.length;
+  return departing.length === 1 && only !== undefined && scaled >= MIN_SCALED_ROWS ? { pair: only, scaled } : undefined;
+};
+
+/** What `amount` would be if it were `ratio` times `from`, in the unit `amount` is written in. */
+export const expectedOf = (from: Amount, amount: Amount, ratio: number): number => {
+  const perWritten = amount.written === 0 || amount.amount === 0 ? 1 : amount.amount / amount.written;
+  return (from.amount * ratio) / perWritten;
+};
+
+const columnSlip = (base: Column, other: Column, { pair, scaled }: Departure): ScaleSlip => ({
+  item: pair.row.item,
+  cell: pair.cell,
+  heading: other.heading,
+  other: pair.baseCell,
+  otherHeading: base.heading,
+  expected: expectedOf(pair.from, pair.to, other.servings / base.servings),
+  scaledRows: scaled,
+});
+
+const baseSlip = (base: Column, other: Column, { pair, scaled }: Departure): ScaleSlip => ({
+  item: pair.row.item,
+  cell: pair.baseCell,
+  heading: base.heading,
+  other: pair.cell,
+  otherHeading: other.heading,
+  expected: expectedOf(pair.to, pair.from, base.servings / other.servings),
+  scaledRows: scaled,
+});
+
+type Found = { readonly other: Column; readonly departure: Departure | undefined };
+
+/** Whether the row's cells outside the first column scale with each other (a row fixed in every column does not). */
+const othersAgree = (found: readonly Found[]): boolean => {
+  const perServing = found.map(({ other, departure }) => (departure === undefined ? Number.NaN : departure.pair.to.amount / other.servings));
+  const [first] = perServing;
+  return first !== undefined && perServing.every((value) => Math.abs(value - first) <= SAME * Math.max(Math.abs(first), 1));
+};
+
+/**
+ * One table's slips. Each column is compared with the first servings column. When the same row departs in every other column
+ * (three or more columns) and those columns scale with each other, it is the first column's cell that is off, and that cell is
+ * reported once; a row that departs everywhere without that (the same amount in every column) may be fixed on purpose.
+ */
+const tableSlips = (columns: readonly Column[], rows: readonly Row[], words: ScaleWords): ScaleSlip[] => {
+  const [base, ...others] = columns;
+  if (base === undefined) return [];
+  const found: Found[] = others.map((other) => ({ other, departure: departureOf(rows, base, other, words) }));
+  const [first] = found;
+  const offRows = new Set(found.map(({ departure }) => departure?.pair.row));
+  if (others.length > 1 && offRows.size === 1 && first?.departure !== undefined) {
+    return othersAgree(found) ? [baseSlip(base, first.other, first.departure)] : [];
+  }
+  return found.flatMap(({ other, departure }) => (departure === undefined ? [] : [columnSlip(base, other, departure)]));
+};
+
+const columnsOf = (header: Line, marks: readonly Mark[]): Column[] =>
+  cellsOf(header).flatMap((cell, index): Column[] => {
+    const servings = index === 0 ? undefined : servingsOf(cell.text, marks);
+    return servings === undefined ? [] : [{ index, servings, heading: withoutEdgeMarks(cell.text.trim()) }];
+  });
+
+/** Every table of the source with two or more servings columns, and the cells in them that do not scale. */
+export const scaleSlips = (source: string, words: ScaleWords): ScaleSlip[] =>
+  tablesOf(linesOf(source)).flatMap((table) => {
+    const columns = columnsOf(table.header, words.columns);
+    const distinct = new Set(columns.map((column) => column.servings));
+    return distinct.size === columns.length && columns.length >= MIN_COLUMNS ? tableSlips(columns, rowsOf(table.rows), words) : [];
+  });