chaffjs 0.29.0 → 0.31.0

package/src/structure/measured-amounts.ts

@@ -0,0 +1,138 @@
+import type { Amount } from "./total.ts";
+import type { MeasureUnit } from "../facts/measures.ts";
+import { CONTINUES_WORD, NUMBER, overlapsAny, valueOf } from "./counted-amounts.ts";
+
+/**
+ * 足してよい、単位の付いた量（300 mg、0.5 g、2 L、3 cm）。単位は量の種類（dimension）と、基準の単位への倍率（factors）を持つ。
+ * 同じ種類の量は、その種類で一番小さい単位に直して足す（500 mg と 0.5 g は 1,000 mg）。倍率が二つある単位（cup）は換算が決まらない。
+ */
+export type SummedMeasure = Pick<MeasureUnit, "pattern" | "dimension" | "factors" | "before" | "context">;
+
+/** 足せない量の印。目安の印（約、about、程度）、範囲の印（〜）、何あたりかの印（数の前の $3 / 200 g、単位の後ろの 300 mg/錠、per tablet）。 */
+export type MeasureMarks = {
+  readonly roughBefore: readonly string[];
+  readonly roughAfter: readonly string[];
+  readonly connectors: readonly string[];
+  readonly perMarks: readonly string[];
+};
+
+/**
+ * 足せない量の単位に付ける印。量は読むが、単位に位置も入れて、ほかのどの量とも同じ単位にならないようにする。その量がある列の和は取らない。
+ * 読まずに捨てると、その行が空の升に見えて、残りの行の和を合計と比べてしまう。
+ */
+const UNSUMMABLE = "?";
+
+const LOOKAHEAD = 32;
+const LATIN = /\p{Script=Latin}/u;
+const DIGIT_AT_END = /\p{N}$/u;
+
+const lineStartOf = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+/** text が word で終わり、英字の語なら語の途中（awesome の some）でない。 */
+const endsWithWord = (text: string, word: string): boolean => {
+  if (!text.toLowerCase().endsWith(word.toLowerCase())) return false;
+  return !LATIN.test(word.charAt(0)) || !LATIN.test(text.charAt(text.length - word.length - 1));
+};
+
+/** text が word で始まり、英字の語なら語の途中（personal の per）でない。 */
+const startsWithWord = (text: string, word: string): boolean => {
+  if (!text.toLowerCase().startsWith(word.toLowerCase())) return false;
+  return !LATIN.test(word.at(-1) ?? "") || !LATIN.test(text.charAt(word.length));
+};
+
+/**
+ * 数の前の目安の印（約300mg、about 300 mg）、何あたりかの印（$3 / 200 g、$3 per 200 g）、
+ * 範囲の後ろの端（300〜400mg、300 - 400 mg）。
+ */
+const markedBefore = (source: string, start: number, marks: MeasureMarks): boolean => {
+  const before = source.slice(lineStartOf(source, start), start);
+  const trimmed = before.trimEnd();
+  if ([...marks.roughBefore, ...marks.perMarks].some((word) => endsWithWord(trimmed, word))) return true;
+  return marks.connectors.some(
+    (connector) => before.endsWith(connector) || (trimmed.endsWith(connector) && DIGIT_AT_END.test(trimmed.slice(0, -connector.length).trimEnd())),
+  );
+};
+
+/** 印の前に置かれうる、開き括弧と空白（5 mg (per tablet)）。 */
+const OPENING = /^[\s(（[［]+/u;
+
+/** 単位の後ろの、目安の印（300mg程度）か何あたりかの印（300 mg/tablet、300 mg per tablet、5 mg (per tablet)）。 */
+const markedAfter = (source: string, end: number, marks: MeasureMarks): boolean => {
+  const after = source.slice(end, end + LOOKAHEAD).replace(OPENING, "");
+  return [...marks.roughAfter, ...marks.perMarks].some((word) => startsWithWord(after, word));
+};
+
+type Found = { readonly measure: SummedMeasure; readonly end: number };
+
+const lineAt = (source: string, offset: number): string => {
+  const end = source.indexOf("\n", offset);
+  return source.slice(lineStartOf(source, offset), end === -1 ? source.length : end);
+};
+
+/** 文脈の語が要る単位（unit-context）は、同じ行にその語があるときだけ単位。 */
+const inContext = (measure: SummedMeasure, source: string, offset: number): boolean => {
+  if (measure.context.length === 0) return true;
+  const line = lineAt(source, offset).toLowerCase();
+  return measure.context.some((word) => line.includes(word.toLowerCase()));
+};
+
+/** 数のすぐ後ろ（空白一つまで）の単位。長い単位から試す（mg を m で切らない）。大文字と小文字は区別する（mL と ML は別）。 */
+const measureAfter = (source: string, end: number, measures: readonly SummedMeasure[], marks: MeasureMarks): Found | undefined => {
+  const gap = source.charAt(end) === " " ? 1 : 0;
+  const rest = source.slice(end + gap, end + gap + LOOKAHEAD);
+  const measure = measures.find((candidate) => {
+    if (candidate.before || !rest.startsWith(candidate.pattern) || !inContext(candidate, source, end)) return false;
+    const unitEnd = end + gap + candidate.pattern.length;
+    return markedAfter(source, unitEnd, marks) || !CONTINUES_WORD.test(rest.slice(candidate.pattern.length));
+  });
+  return measure === undefined ? undefined : { measure, end: end + gap + measure.pattern.length };
+};
+
+/** 量の種類ごとの、一番小さい倍率。倍率が一つの単位だけから取る。 */
+const baseFactors = (measures: readonly SummedMeasure[]): Map<string, number> =>
+  measures.reduce((bases, measure) => {
+    const [factor] = measure.factors;
+    if (measure.factors.length !== 1 || factor === undefined || factor <= 0) return bases;
+    return bases.set(measure.dimension, Math.min(bases.get(measure.dimension) ?? factor, factor));
+  }, new Map<string, number>());
+
+const unsummable = (offset: number, end: number, value: number, measure: SummedMeasure): Amount => ({
+  offset,
+  end,
+  value,
+  unit: `${measure.dimension}${UNSUMMABLE}${String(offset)}`,
+});
+
+const amountOf = (source: string, start: number, written: string, found: Found, bases: Map<string, number>, marks: MeasureMarks): Amount => {
+  const value = valueOf(written);
+  const { measure } = found;
+  const [factor] = measure.factors;
+  const base = bases.get(measure.dimension);
+  const sure = measure.factors.length === 1 && factor !== undefined && base !== undefined;
+  if (!sure || markedBefore(source, start, marks) || markedAfter(source, found.end, marks)) return unsummable(start, found.end, value, measure);
+  const scale = factor / base;
+  return { offset: start, end: found.end, value: value * scale, unit: measure.dimension, scale };
+};
+
+/**
+ * 数のすぐ前（空白一つまで）の単位（大さじ1）は、足さない量として読む。読まずに捨てると、その行が空の升に見えてしまう。
+ */
+const measureBefore = (source: string, start: number, end: number, measures: readonly SummedMeasure[]): Amount | undefined => {
+  const gap = source.charAt(start - 1) === " " ? 1 : 0;
+  const head = source.slice(Math.max(0, start - gap - LOOKAHEAD), start - gap);
+  const measure = measures.find((candidate) => candidate.before && head.endsWith(candidate.pattern) && inContext(candidate, source, start));
+  return measure === undefined ? undefined : unsummable(start - gap - measure.pattern.length, end, valueOf(source.slice(start, end)), measure);
+};
+
+/** 文書の中の、単位の付いた量。値は量の種類で一番小さい単位に直す。木がすでに数量として読んだもの（known）とは重ねない。 */
+export const measuredAmounts = (source: string, measures: readonly SummedMeasure[], marks: MeasureMarks, known: readonly Amount[]): Amount[] => {
+  const longestFirst = measures.toSorted((left, right) => right.pattern.length - left.pattern.length);
+  const bases = baseFactors(measures);
+  return [...source.matchAll(NUMBER)].flatMap((match): Amount[] => {
+    const end = match.index + match[0].length;
+    const found = measureAfter(source, end, longestFirst, marks);
+    if (found !== undefined) return overlapsAny(match.index, found.end, known) ? [] : [amountOf(source, match.index, match[0], found, bases, marks)];
+    const before = measureBefore(source, match.index, end, longestFirst);
+    return before === undefined || overlapsAny(before.offset, before.end, known) ? [] : [before];
+  });
+};

package/src/structure/party-order.ts

@@ -0,0 +1,115 @@
+import type { BodyText } from "./definition-use.ts";
+
+/**
+ * 当事者の呼び名を並べた所（甲及び乙、甲又は乙、甲乙、甲、乙及び丙）と、文書がふだん書く順と逆に並べた所。
+ * 並べる語は言語パッケージの語彙表から取る。向きのある言い方（乙から甲へ、甲が乙に）は並べる語でつながないので読まない。
+ */
+export type ListingWords = {
+  /** 当事者の呼び名（甲、乙、文書が定めた委託者）。 */
+  readonly labels: readonly string[];
+  /** 間に語を置かずに並べてよい呼び名（甲乙）。 */
+  readonly bareLabels: readonly string[];
+  /** 並べる語（及び、又は、・）。 */
+  readonly joiners: readonly string[];
+  /** 同じ並びのあとに並べる語があるときだけつなぐ印（甲、乙及び丙の「、」）。 */
+  readonly seriesMarks: readonly string[];
+};
+
+export type PartyListing = { readonly start: number; readonly end: number; readonly labels: readonly string[] };
+
+export type OrderSlip = { readonly listing: PartyListing; readonly usual: PartyListing; readonly usualCount: number; readonly reverseCount: number };
+
+type Link = "joiner" | "series" | "bare";
+type Step = { readonly link: Link; readonly label: string; readonly end: number };
+
+/** 呼び名の前の一字がこれなら、呼び名は長い語の一部（乙種の前の語、1丁目）。 */
+const WORD_CHAR = /[\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}ー]/u;
+
+const longestAt = (text: string, at: number, words: readonly string[]): string | undefined =>
+  words
+    .filter((word) => word !== "" && text.startsWith(word, at))
+    .reduce<string | undefined>((best, word) => (best === undefined || word.length > best.length ? word : best), undefined);
+
+const stepAfter = (text: string, at: number, previous: string, words: ListingWords): Step | undefined => {
+  const linked = (link: Link, mark: string | undefined): Step | undefined => {
+    if (mark === undefined) return undefined;
+    const label = longestAt(text, at + mark.length, words.labels);
+    return label === undefined ? undefined : { link, label, end: at + mark.length + label.length };
+  };
+  const bare = words.bareLabels.includes(previous) ? longestAt(text, at, words.bareLabels) : undefined;
+  const side: Step | undefined = bare === undefined ? undefined : { link: "bare", label: bare, end: at + bare.length };
+  return linked("joiner", longestAt(text, at, words.joiners)) ?? linked("series", longestAt(text, at, words.seriesMarks)) ?? side;
+};
+
+/** 並べた語の数。「、」は、そのあとに並べる語が無ければ並びの終わり（「甲、乙は」は並べたと読まない）。 */
+const linksKept = (links: readonly Link[]): number => {
+  const lastJoiner = links.lastIndexOf("joiner");
+  const series = links.findIndex((link, index) => link === "series" && index > lastJoiner);
+  return series === -1 ? links.length : series;
+};
+
+/** 最後の呼び名が長い語の頭なら並びに入れない（乙及び甲種株式の甲）。間を置かずに並べた甲乙は、あとに語が続いてよい（甲乙間、甲乙双方）。 */
+const endsInWord = (text: string, steps: readonly Step[]): boolean => {
+  const last = steps.at(-1);
+  return last !== undefined && last.link !== "bare" && WORD_CHAR.test(text.charAt(last.end));
+};
+
+const listingAt = (text: BodyText, at: number, first: string, words: ListingWords): PartyListing => {
+  const steps: Step[] = [];
+  let end = at + first.length;
+  for (let step = stepAfter(text.text, end, first, words); step !== undefined; step = stepAfter(text.text, end, step.label, words)) {
+    steps.push(step);
+    end = step.end;
+  }
+  const whole = endsInWord(text.text, steps) ? steps.slice(0, -1) : steps;
+  const kept = whole.slice(0, linksKept(whole.map((step) => step.link)));
+  const last = kept.at(-1);
+  return { start: text.start + at, end: text.start + (last === undefined ? at + first.length : last.end), labels: [first, ...kept.map((step) => step.label)] };
+};
+
+/** 一つの文の中の並び。呼び名が二つ以上で、違う呼び名を並べたものだけ。 */
+const listingsIn = (text: BodyText, words: ListingWords): PartyListing[] => {
+  const found: PartyListing[] = [];
+  let at = 0;
+  while (at < text.text.length) {
+    const first = WORD_CHAR.test(text.text.charAt(at - 1)) ? undefined : longestAt(text.text, at, words.labels);
+    const listing = first === undefined ? undefined : listingAt(text, at, first, words);
+    if (listing !== undefined && new Set(listing.labels).size > 1) found.push(listing);
+    at = listing !== undefined && listing.labels.length > 1 ? listing.end - text.start : at + 1;
+  }
+  return found;
+};
+
+export const partyListings = (texts: readonly BodyText[], words: ListingWords): PartyListing[] => texts.flatMap((text) => listingsIn(text, words));
+
+const pairsOf = (labels: readonly string[]): [string, string][] =>
+  labels.flatMap((first, index) => labels.slice(index + 1).flatMap((second): [string, string][] => (second === first ? [] : [[first, second]])));
+
+const keyOf = (left: string, right: string): string => `${left}\u0000${right}`;
+
+const byPair = (listings: readonly PartyListing[]): Map<string, PartyListing[]> => {
+  const pairs = new Map<string, PartyListing[]>();
+  listings.forEach((listing) =>
+    new Set(pairsOf(listing.labels).map(([first, second]) => keyOf(first, second))).forEach((key) => pairs.set(key, [...(pairs.get(key) ?? []), listing])),
+  );
+  return pairs;
+};
+
+/**
+ * 文書がふだん書く順と逆に並べた所。ふだんの順は、同じ二つの呼び名を並べた所の多い方で、逆の順の minRatio 倍以上あるときだけ
+ * 決まる（同じ数なら、どちらとも言えないので指さない）。
+ */
+export const reversedListings = (listings: readonly PartyListing[], minRatio: number): OrderSlip[] => {
+  const pairs = byPair(listings);
+  return listings.flatMap((listing) => {
+    const slips = pairsOf(listing.labels).flatMap(([first, second]): OrderSlip[] => {
+      const reverse = pairs.get(keyOf(first, second)) ?? [];
+      const usual = pairs.get(keyOf(second, first)) ?? [];
+      const example = usual[0];
+      return example === undefined || usual.length < minRatio * reverse.length
+        ? []
+        : [{ listing, usual: example, usualCount: usual.length, reverseCount: reverse.length }];
+    });
+    return slips.slice(0, 1);
+  });
+};

package/src/structure/quantity-range.ts

@@ -0,0 +1,54 @@
+// 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";
+
+const LATIN_EDGE = /[A-Za-z]$/u;
+const LATIN_START = /^[A-Za-z]/u;
+
+/** A Latin unit running into a word is part of that word: the t of "40 to" is not a tonne. */
+const standsAlone = (text: string, measured: Measured): boolean =>
+  !(LATIN_EDGE.test(measured.unit) && LATIN_START.test(text.slice(measured.end, measured.end + 1)));
+
+/** 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) => standsAlone(text, 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));

package/src/structure/range-bands.ts

@@ -0,0 +1,316 @@
+// range-band-mismatch: the bands of one table column or one list (7〜11歳, 12〜14歳, 15歳以上; under 7, 7 to 11, 12 and over)
+// that overlap or leave a gap between neighbours. The words that bound a band and the units it is counted in come from the
+// lexicons (range-band-word, range-band-unit, range-band-heading). Pure.
+
+/** How an end of a band is written: 以上/以下 (inclusive), 未満/超 (exclusive), or only a range mark (7〜11, 7 to 11). */
+export type BoundKind = "inclusive" | "exclusive" | "loose";
+
+export type Bound = { readonly value: number; readonly kind: BoundKind; readonly decimals: number };
+
+/** Integer units (ages, people, points) have no value between 11 and 12; continuous ones (kg, yen, hours) do. */
+export type UnitKind = "integer" | "continuous";
+
+export type Band = { readonly low: Bound | undefined; readonly high: Bound | undefined; readonly unit: string };
+
+export type BandMarker = {
+  readonly pattern: string;
+  readonly side: "low" | "high";
+  readonly kind: "inclusive" | "exclusive";
+  readonly position: "before" | "after";
+};
+
+export type BandUnit = { readonly pattern: string; readonly kind: UnitKind; readonly position: "before" | "after" };
+
+export type BandWords = {
+  /** Marks between the two ends (〜, –, to). Written after a number alone (12歳〜) it leaves the band open above. */
+  readonly connectors: readonly string[];
+  /** The marks that, before a number alone (〜6歳), close a band above. A hyphen is not one: "- 5" is a bullet or a minus. */
+  readonly openers: readonly string[];
+  readonly markers: readonly BandMarker[];
+  /** Words a band may open with that say nothing about its ends ("ages", "aged"). */
+  readonly leads: readonly string[];
+  readonly units: readonly BandUnit[];
+  /** Column headings that name what bare numbers count (年齢, Age), with the kind of that quantity. */
+  readonly headings: readonly { readonly pattern: string; readonly kind: UnitKind }[];
+};
+
+/** One band as written, with where it is. */
+export type PlacedBand = { readonly band: Band; readonly start: number; readonly end: number; readonly text: string };
+
+export type BandSlip = { readonly kind: "overlap" | "gap"; readonly earlier: PlacedBand; readonly later: PlacedBand };
+
+const NUMBER = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?/u;
+const LATIN_END = /[a-z]$/u;
+const LETTER = /^[a-z]/u;
+const SPACE = /^\s*/u;
+const EMPHASIS = /[*_`]/gu;
+
+/** The text without a note in brackets at its end (15歳以上（成人）), and the note. */
+const splitNote = (text: string): { readonly bare: string; readonly note: string | undefined } => {
+  const open = text.lastIndexOf("(");
+  if (!text.endsWith(")") || open === -1) return { bare: text, note: undefined };
+  return { bare: text.slice(0, open).trim(), note: text.slice(open + 1, -1).trim() };
+};
+
+const plainOf = (text: string): string => text.normalize("NFKC").toLowerCase().replace(EMPHASIS, "").trim();
+
+export const normalizeBandText = (text: string): string => splitNote(plainOf(text)).bare;
+
+const normalizeWord = (word: string): string => word.normalize("NFKC").toLowerCase();
+
+/** A unit compared across bands: years and year, kg and kgs are the same unit. */
+const unitKey = (unit: string): string => (unit.length > 2 && unit.endsWith("s") ? unit.slice(0, -1) : unit);
+
+type Cursor = { readonly text: string; readonly at: number };
+
+const skipSpace = (cursor: Cursor): Cursor => ({ text: cursor.text, at: cursor.at + (SPACE.exec(cursor.text.slice(cursor.at))?.[0].length ?? 0) });
+
+/** The longest word at the cursor; a Latin word must end at a word edge (to is not the start of total). */
+const wordAt = (cursor: Cursor, words: readonly string[]): string | undefined =>
+  words
+    .map(normalizeWord)
+    .filter((word) => word !== "" && cursor.text.startsWith(word, cursor.at))
+    .filter((word) => !LATIN_END.test(word) || !LETTER.test(cursor.text.slice(cursor.at + word.length)))
+    .reduce<string | undefined>((best, word) => (best === undefined || word.length > best.length ? word : best), undefined);
+
+const advance = (cursor: Cursor, word: string | undefined): Cursor =>
+  word === undefined ? cursor : skipSpace({ text: cursor.text, at: cursor.at + word.length });
+
+type Read<T> = { readonly value: T; readonly cursor: Cursor } | undefined;
+
+const numberAt = (cursor: Cursor): Read<{ value: number; decimals: number }> => {
+  const written = NUMBER.exec(cursor.text.slice(cursor.at))?.[0];
+  if (written === undefined) return undefined;
+  const digits = written.replaceAll(",", "");
+  return { value: { value: Number(digits), decimals: digits.split(".")[1]?.length ?? 0 }, cursor: advance(cursor, written) };
+};
+
+const unitsAt = (cursor: Cursor, words: BandWords, position: "before" | "after"): Read<string | undefined> => {
+  const unit = wordAt(
+    cursor,
+    words.units.filter((entry) => entry.position === position).map((entry) => entry.pattern),
+  );
+  return { value: unit, cursor: advance(cursor, unit) };
+};
+
+const markerAt = (cursor: Cursor, words: BandWords, position: "before" | "after"): Read<BandMarker | undefined> => {
+  const markers = words.markers.filter((marker) => marker.position === position);
+  const word = wordAt(
+    cursor,
+    markers.map((marker) => marker.pattern),
+  );
+  return { value: markers.find((marker) => normalizeWord(marker.pattern) === word), cursor: advance(cursor, word) };
+};
+
+/** One number with the units written around it ($5, 7歳, 8 years). */
+type Figure = { readonly value: number; readonly decimals: number; readonly units: readonly string[] };
+
+const figureAt = (cursor: Cursor, words: BandWords): Read<Figure> => {
+  const prefix = unitsAt(cursor, words, "before");
+  const number = prefix === undefined ? undefined : numberAt(prefix.cursor);
+  const suffix = number === undefined ? undefined : unitsAt(number.cursor, words, "after");
+  if (prefix === undefined || number === undefined || suffix === undefined) return undefined;
+  const units = [prefix.value, suffix.value].filter((unit) => unit !== undefined);
+  return { value: { ...number.value, units }, cursor: suffix.cursor };
+};
+
+const boundOf = (figure: Figure, kind: BoundKind): Bound => ({ value: figure.value, kind, decimals: figure.decimals });
+
+/** A band with the units it was written in. undefined when the text is not one band of one unit. */
+type Parsed = { readonly low: Bound | undefined; readonly high: Bound | undefined; readonly units: readonly string[] };
+
+const withMarker = (figure: Figure, marker: BandMarker): Parsed => ({
+  low: marker.side === "low" ? boundOf(figure, marker.kind) : undefined,
+  high: marker.side === "high" ? boundOf(figure, marker.kind) : undefined,
+  units: figure.units,
+});
+
+/** One end with its word: 15歳以上, 7 and over, under 7. */
+const markedEnd = (cursor: Cursor, words: BandWords): Read<{ readonly parsed: Parsed; readonly side: "low" | "high" }> => {
+  const before = markerAt(cursor, words, "before");
+  const figure = before === undefined ? undefined : figureAt(before.cursor, words);
+  const after = figure === undefined ? undefined : markerAt(figure.cursor, words, "after");
+  if (before === undefined || figure === undefined || after === undefined) return undefined;
+  const marker = before.value ?? after.value;
+  if (marker === undefined || (before.value !== undefined && after.value !== undefined)) return undefined;
+  const unit = unitsAt(after.cursor, words, "after");
+  if (unit === undefined) return undefined;
+  const parsed = withMarker(figure.value, marker);
+  return {
+    value: { parsed: { ...parsed, units: [...parsed.units, ...(unit.value === undefined ? [] : [unit.value])] }, side: marker.side },
+    cursor: unit.cursor,
+  };
+};
+
+/** 15歳以上, under 7, and both ends with their words: 7歳以上12歳未満. */
+const markedBand = (cursor: Cursor, words: BandWords): Read<Parsed> => {
+  const first = markedEnd(cursor, words);
+  if (first === undefined) return undefined;
+  const rest = first.value.side === "low" ? markedEnd(first.cursor, words) : undefined;
+  if (rest === undefined || rest.value.side !== "high") return { value: first.value.parsed, cursor: first.cursor };
+  const units = [...first.value.parsed.units, ...rest.value.parsed.units];
+  return { value: { low: first.value.parsed.low, high: rest.value.parsed.high, units }, cursor: rest.cursor };
+};
+
+/** 7〜11歳, 7 to 11, 12歳〜, 〜6歳. */
+const spannedBand = (cursor: Cursor, words: BandWords): Read<Parsed> => {
+  const leading = wordAt(cursor, words.openers);
+  const first = figureAt(advance(cursor, leading), words);
+  if (first === undefined) return undefined;
+  if (leading !== undefined) return { value: { low: undefined, high: boundOf(first.value, "loose"), units: first.value.units }, cursor: first.cursor };
+  const connector = wordAt(first.cursor, words.connectors);
+  if (connector === undefined) return undefined;
+  const second = figureAt(advance(first.cursor, connector), words);
+  if (second === undefined)
+    return { value: { low: boundOf(first.value, "loose"), high: undefined, units: first.value.units }, cursor: advance(first.cursor, connector) };
+  return {
+    value: { low: boundOf(first.value, "loose"), high: boundOf(second.value, "loose"), units: [...first.value.units, ...second.value.units] },
+    cursor: second.cursor,
+  };
+};
+
+/** The band a cell or the head of a list item states, or undefined when the whole text is not one band in one unit. */
+export const parseBand = (written: string, words: BandWords): Band | undefined => {
+  const text = normalizeBandText(written);
+  const start = skipSpace({ text, at: 0 });
+  const begun = advance(start, wordAt(start, words.leads));
+  const read = [begun, start]
+    .flatMap((cursor) => [markedBand(cursor, words), spannedBand(cursor, words)])
+    .find((reading) => reading !== undefined && reading.cursor.at === text.length);
+  if (read === undefined) return undefined;
+  const units = new Set(read.value.units.map(unitKey));
+  if (units.size > 1) return undefined;
+  const { low, high } = read.value;
+  if (low !== undefined && high !== undefined && low.value >= high.value) return undefined;
+  return { low, high, unit: [...units][0] ?? "" };
+};
+
+/** The kind of a unit, by the unit lexicon. */
+export const unitKindOf = (unit: string, words: BandWords): UnitKind | undefined =>
+  words.units.find((entry) => unitKey(normalizeWord(entry.pattern)) === unit)?.kind;
+
+/** What bare numbers under a column heading count: by a word of the heading lexicon, or a unit in brackets (体重(kg)). */
+export const headingOf = (heading: string, words: BandWords): { readonly unit: string; readonly kind: UnitKind } | undefined => {
+  const { bare, note } = splitNote(plainOf(heading).replaceAll("[", "(").replaceAll("]", ")"));
+  const unit = note === undefined ? undefined : unitKey(note);
+  const unitKind = unit === undefined ? undefined : unitKindOf(unit, words);
+  if (unit !== undefined && unitKind !== undefined) return { unit, kind: unitKind };
+  const named = words.headings.find((entry) => normalizeWord(entry.pattern) === bare);
+  return named === undefined ? undefined : { unit: "", kind: named.kind };
+};
+
+type Span = { readonly low: number; readonly high: number };
+
+const POSITIVE = Number.POSITIVE_INFINITY;
+const NEGATIVE = Number.NEGATIVE_INFINITY;
+
+/** The band as the values it holds. An integer band's exclusive end is the next whole number in (7歳未満 holds up to 6). */
+const spanOf = (band: Band, integer: boolean): Span => {
+  const step = integer ? 1 : 0;
+  const inward = (bound: Bound): number => (bound.kind === "exclusive" ? step : 0);
+  return {
+    low: band.low === undefined ? NEGATIVE : band.low.value + inward(band.low),
+    high: band.high === undefined ? POSITIVE : band.high.value - inward(band.high),
+  };
+};
+
+/** Bands written in one direction, each starting and ending past the one before. Nested tiers (〜100万円, 〜200万円) are not. */
+const orderOf = (spans: readonly Span[]): "up" | "down" | undefined => {
+  const pairs = spans.slice(1).flatMap((span, index): [Span, Span][] => {
+    const previous = spans[index];
+    return previous === undefined ? [] : [[previous, span]];
+  });
+  if (pairs.every(([a, b]) => a.low < b.low && a.high < b.high)) return "up";
+  if (pairs.every(([a, b]) => a.low > b.low && a.high > b.high)) return "down";
+  return undefined;
+};
+
+/** Smallest step the two numbers are written to (59 and 60: 1; 59.9 and 60: 0.1). */
+const stepOf = (a: Bound, b: Bound): number => 10 ** -Math.max(a.decimals, b.decimals);
+
+const ROUNDING = 1e-9;
+
+type Meeting = "overlap" | "gap" | undefined;
+
+/** Whole numbers: the next band starts one past the end of the one below. */
+const integerJunction = (below: Band, above: Band): Meeting => {
+  const distance = spanOf(above, true).low - spanOf(below, true).high;
+  if (distance <= 0) return "overlap";
+  return distance > 1 ? "gap" : undefined;
+};
+
+/** At one number, an end included on both sides overlaps and one excluded on both sides leaves the number out. */
+const sameNumber = (end: Bound, start: Bound): Meeting => {
+  if (start.kind === "inclusive" && end.kind === "inclusive") return "overlap";
+  return start.kind === "exclusive" && end.kind === "exclusive" ? "gap" : undefined;
+};
+
+/** Values in between: a shared end with a range mark, or ends a written step apart, are contiguous. */
+const continuousJunction = (end: Bound, start: Bound): Meeting => {
+  if (start.value < end.value) return "overlap";
+  if (start.value === end.value) return sameNumber(end, start);
+  if (start.kind === "exclusive" || end.kind === "exclusive") return "gap";
+  return start.value - end.value > stepOf(start, end) + ROUNDING ? "gap" : undefined;
+};
+
+/** Where the band below ends and the band above starts. */
+const junctionOf = (below: Band, above: Band, integer: boolean): Meeting => {
+  if (below.high === undefined || above.low === undefined) return undefined;
+  return integer ? integerJunction(below, above) : continuousJunction(below.high, above.low);
+};
+
+const widthOf = (span: Span, integer: boolean): number => span.high - span.low + (integer ? 1 : 0);
+
+type Junction = { readonly kind: "overlap" | "gap"; readonly size: number; readonly narrower: number };
+
+/** How much the bands overlap or leave out, next to the narrower of the two. */
+const junctionSize = (kind: "overlap" | "gap", below: Span, above: Span, integer: boolean): Junction => {
+  const edge = integer ? 1 : 0;
+  const size = kind === "overlap" ? below.high - above.low + edge : above.low - below.high - edge;
+  return { kind, size, narrower: Math.min(widthOf(below, integer), widthOf(above, integer)) };
+};
+
+/** An overlap of more than half the narrower band is deliberate: a size guide whose bands share a range. */
+const isDeliberate = (junction: Junction): boolean => junction.kind === "overlap" && junction.size * 2 > junction.narrower;
+
+/**
+ * The overlaps and gaps between neighbouring bands of one column or list. The bands must all be counted in one unit (bare
+ * numbers take the column's), written in one direction; the slip is reported at the later of the two in the document. A run
+ * with one deliberate overlap is a scale meant to overlap, and two bands alone are reported only when the hole or overlap is
+ * no wider than the narrower band.
+ */
+export const bandSlips = (bands: readonly PlacedBand[], kind: UnitKind): BandSlip[] => {
+  if (bands.length < 2) return [];
+  const integer = kind === "integer" && bands.every(({ band }) => [band.low, band.high].every((bound) => bound === undefined || bound.decimals === 0));
+  const order = orderOf(bands.map(({ band }) => spanOf(band, integer)));
+  if (order === undefined) return [];
+  const ascending = order === "up" ? [...bands] : [...bands].reverse();
+  const junctions = ascending.slice(1).flatMap((above, index) => {
+    const below = ascending[index];
+    const slip = below === undefined ? undefined : junctionOf(below.band, above.band, integer);
+    return below === undefined || slip === undefined
+      ? []
+      : [{ below, above, ...junctionSize(slip, spanOf(below.band, integer), spanOf(above.band, integer), integer) }];
+  });
+  if (junctions.some(isDeliberate)) return [];
+  const pair = bands.length === 2;
+  return junctions
+    .filter((junction) => !pair || junction.size <= junction.narrower)
+    .map(({ below, above, kind: slip }) => {
+      const [earlier, later] = below.start < above.start ? [below, above] : [above, below];
+      return { kind: slip, earlier, later };
+    });
+};
+
+/** The unit and kind of a run of bands: one unit for all (bare numbers take the heading's), or undefined. */
+export const runKindOf = (
+  bands: readonly Band[],
+  heading: { readonly unit: string; readonly kind: UnitKind } | undefined,
+  words: BandWords,
+): UnitKind | undefined => {
+  const units = new Set([...bands.map((band) => band.unit), heading?.unit ?? ""].filter((unit) => unit !== ""));
+  if (units.size > 1) return undefined;
+  const unit = [...units][0];
+  if (unit === undefined) return heading?.kind;
+  return unitKindOf(unit, words);
+};