chaffjs 0.28.0 → 0.30.0

package/src/deprecated-use.ts

@@ -0,0 +1,122 @@
+// A name the document calls deprecated (`indent` is deprecated; | `indent` | 0 | 非推奨 |) still used in one of its code
+// examples ({ indent: 2 }, --indent, indent=2). Pure; reads the Markdown source. The words that mark a name deprecated
+// (deprecated, 非推奨) and the phrases that negate them come from the language's lexicons.
+import { codeFences } from "./detectors/code-fences.ts";
+
+/** A deprecated name used in code: where it is used, and where the document calls it deprecated. */
+export type DeprecatedUse = { readonly name: string; readonly offset: number; readonly marked: number };
+
+/** The lowercase words that mark a name deprecated, and the phrases that negate one ("not deprecated", 非推奨ではな). */
+export type DeprecationWords = { readonly words: readonly string[]; readonly negated: readonly string[] };
+
+type Line = { readonly text: string; readonly start: number };
+type Marked = { readonly name: string; readonly offset: number };
+type Span = { readonly start: number; readonly end: number };
+type Found = { readonly at: number; readonly end: number };
+
+/** A name in code marks: `indent`, or the flag `--indent`, which is the name indent. */
+const CODE_SPAN = /`-{0,2}([A-Za-z_$][\w$-]*)`/gu;
+const FIRST_CELL_NAME = /`-{0,2}([A-Za-z_$][\w$-]*)`|^\s*-{0,2}([A-Za-z_$][\w$-]*)\s*$/u;
+const TABLE_ROW = /^[ \t]{0,3}\|/u;
+/** An anchor before a field name in a table cell: <a name="schemaExample"></a>example. */
+const HTML_TAG = /<[^<>]*>/gu;
+/** Where one statement ends: a sentence or a clause after a semicolon ("`indent` is deprecated; use `prefix`"). */
+const STATEMENT_END = /[.;。；!?！？]/u;
+/** A block that declares an API (interface Options { indent: number }) documents the name, and does not use it. */
+const DECLARATION_BLOCK = /^[ \t]*(?:export[ \t]+)?(?:interface|class|type[ \t]+[\w$]+[ \t]*=)/mu;
+
+const linesOf = (source: string): Line[] => {
+  const starts = [0, ...[...source.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ text: source.slice(start, (starts[index + 1] ?? source.length + 1) - 1), start }));
+};
+
+const insideOne = (spans: readonly Span[], offset: number): boolean => spans.some((span) => offset >= span.start && offset < span.end);
+
+const occurrences = (text: string, words: readonly string[]): Found[] => {
+  const lower = text.toLowerCase();
+  return words.flatMap((word) => {
+    const found: Found[] = [];
+    for (let at = lower.indexOf(word); at !== -1; at = lower.indexOf(word, at + word.length)) found.push({ at, end: at + word.length });
+    return found;
+  });
+};
+
+/** The deprecation words in a text, less those inside a negated phrase ("is not deprecated"). */
+const wordsIn = (text: string, words: DeprecationWords): Found[] => {
+  const negated = occurrences(text, words.negated);
+  return occurrences(text, words.words).filter((word) => !negated.some((phrase) => phrase.at <= word.at && word.end <= phrase.end));
+};
+
+/** Characters between a code span and the word: "`indent` を非推奨" is nearer than "非推奨にし、`prefix`". */
+const gap = (span: Found, word: Found): number => (span.end <= word.at ? word.at - span.end : span.at - word.end);
+
+/** A table row's first-cell name, and whether its later cells call it deprecated. */
+const rowOf = (line: Line, words: DeprecationWords): (Marked & { readonly deprecated: boolean }) | undefined => {
+  const cells = line.text.split("|");
+  const first = cells.findIndex((cell) => cell.trim() !== "");
+  if (first === -1) return undefined;
+  const name = FIRST_CELL_NAME.exec((cells[first] ?? "").replace(HTML_TAG, ""));
+  const written = name?.[1] ?? name?.[2];
+  const deprecated = wordsIn(cells.slice(first + 1).join("|"), words).length > 0;
+  return written === undefined ? undefined : { name: written, offset: line.start + line.text.indexOf(written), deprecated };
+};
+
+const markedInRow = (line: Line, words: DeprecationWords): Marked[] => {
+  const row = rowOf(line, words);
+  return row?.deprecated === true ? [{ name: row.name, offset: row.offset }] : [];
+};
+
+/**
+ * Names a table also lists without calling them deprecated: one page may describe two fields of one name, of which only
+ * one is deprecated (an example field of one object, and of another), and an example cannot tell which it uses.
+ */
+const listedAlive = (lines: readonly Line[], words: DeprecationWords): Set<string> =>
+  new Set(
+    lines.flatMap((line) => (line.text.includes("|") ? [rowOf(line, words)] : [])).flatMap((row) => (row === undefined || row.deprecated ? [] : [row.name])),
+  );
+
+/** In a statement, the code name nearest to each deprecation word: "`indent` is deprecated", "Deprecated: `indent`". */
+const markedInProse = (line: Line, words: DeprecationWords): Marked[] =>
+  wordsIn(line.text, words).flatMap((word) => {
+    const { at } = word;
+    const from = Math.max(...[...line.text.slice(0, at).matchAll(new RegExp(STATEMENT_END, "gu"))].map((match) => match.index + 1), 0);
+    const after = line.text.slice(at).search(STATEMENT_END);
+    const to = after === -1 ? line.text.length : at + after;
+    const spans = [...line.text.slice(from, to).matchAll(CODE_SPAN)].map((match) => ({
+      name: match[1] ?? "",
+      at: from + match.index,
+      end: from + match.index + match[0].length,
+    }));
+    const nearest = spans.toSorted((left, right) => gap(left, word) - gap(right, word))[0];
+    return nearest === undefined ? [] : [{ name: nearest.name, offset: line.start + line.text.indexOf(nearest.name, nearest.at) }];
+  });
+
+const escape = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/** A name used as an option in code: a key ({ indent: 2 }, "indent": 2), an argument (indent=2) or a flag (--indent). */
+const usePattern = (name: string): RegExp =>
+  new RegExp(`(?:(?<![\\w$.-])["']?${escape(name)}["']?[ \\t]*(?::(?!:)|=(?!=))|(?<![\\w-])--${escape(name)}(?![\\w-]))`, "u");
+
+const usesIn = (line: Line, marks: ReadonlyMap<string, number>): DeprecatedUse[] =>
+  [...marks].flatMap(([name, marked]) => {
+    const match = usePattern(name).exec(line.text);
+    return match === null ? [] : [{ name, offset: line.start + match.index + match[0].indexOf(name), marked }];
+  });
+
+/**
+ * The code lines that use a name the document calls deprecated. A code line that says so itself (`indent: 2 // deprecated`)
+ * shows the old use on purpose and is left out, and so is a block that declares an API rather than using it.
+ */
+export const deprecatedUses = (source: string, words: DeprecationWords): DeprecatedUse[] => {
+  if (words.words.length === 0) return [];
+  const fences = codeFences(source);
+  const lines = linesOf(source);
+  const prose = lines.filter((line) => !insideOne(fences, line.start));
+  const alive = listedAlive(prose, words);
+  const marked = prose
+    .flatMap((line) => (TABLE_ROW.test(line.text) ? markedInRow(line, words) : markedInProse(line, words)))
+    .filter((mark) => !alive.has(mark.name));
+  const firstMark = new Map(marked.toReversed().map((mark) => [mark.name, mark.offset]));
+  const examples = fences.filter((fence) => !DECLARATION_BLOCK.test(source.slice(fence.start, fence.end)));
+  return lines.filter((line) => insideOne(examples, line.start) && wordsIn(line.text, words).length === 0).flatMap((line) => usesIn(line, firstMark));
+};

package/src/derived/session-hours.ts

@@ -0,0 +1,62 @@
+import type { Span } from "../plugin.ts";
+import type { Mark } from "../structure/time-marks.ts";
+import { labelOf, readScopes, within, type TimeLength } from "./time-lengths.ts";
+
+/**
+ * A number of sessions times the length of one against the stated total (90分×15回（計24時間）, 15 sessions of 90
+ * minutes, 24 hours in total). Read in one line, or in a list whose items say it together, holding exactly one count of
+ * two or more sessions, one length of a session and one total. A total written as approximate (約24時間, about 24 hours)
+ * may differ by less than the smallest unit it is written in. Pure.
+ */
+export type Count = Span & { readonly amount: number };
+
+export type SessionHoursWords = { readonly totals: readonly Mark[]; readonly approximate: readonly Mark[] };
+
+export type SessionHoursMismatch = {
+  readonly count: Count;
+  readonly length: TimeLength;
+  readonly total: TimeLength;
+  /** The count times the length, in minutes. */
+  readonly expected: number;
+};
+
+const overlaps = (left: Span, right: Span): boolean => left.start < right.end && right.start < left.end;
+
+type Statement = { readonly count: Count; readonly length: TimeLength; readonly total: TimeLength };
+
+/** The length with a rough mark written before it taken in (計約24時間 reads its label past 約). */
+const withRoughMark = (text: string, length: TimeLength, words: SessionHoursWords): Span => {
+  const mark = labelOf(text, length, words.approximate);
+  return mark !== undefined && mark.end <= length.start ? { start: mark.start, end: length.end } : length;
+};
+
+const statementIn = (text: string, scope: Span, counts: readonly Count[], lengths: readonly TimeLength[], words: SessionHoursWords) => {
+  const inCounts = counts.filter((count) => count.amount > 1 && within(count, scope));
+  const inLengths = lengths.filter((length) => within(length, scope));
+  const totals = inLengths.filter((length) => labelOf(text, withRoughMark(text, length, words), words.totals) !== undefined);
+  const sessions = inLengths.filter((length) => !totals.includes(length));
+  const [count, length, total] = [inCounts[0], sessions[0], totals[0]];
+  if (inCounts.length !== 1 || sessions.length !== 1 || totals.length !== 1 || count === undefined || length === undefined || total === undefined)
+    return undefined;
+  if (overlaps(count, length) || labelOf(text, length, words.approximate) !== undefined) return undefined;
+  return { count, length, total } satisfies Statement;
+};
+
+const allowanceOf = (text: string, total: TimeLength, words: SessionHoursWords): number =>
+  labelOf(text, total, words.approximate) === undefined ? 0 : total.unit;
+
+/** Sessions whose count times length is not the stated total. counts are the written counts of sessions (15回, 15 sessions). */
+export const sessionHoursMismatches = (
+  text: string,
+  source: string,
+  sentences: readonly Span[],
+  counts: readonly Count[],
+  lengths: readonly TimeLength[],
+  words: SessionHoursWords,
+): SessionHoursMismatch[] =>
+  readScopes(text, source, { sentences, times: [] }, (scope) => statementIn(text, scope, counts, lengths, words)).flatMap(({ count, length, total }) => {
+    const expected = count.amount * length.minutes;
+    const allowance = allowanceOf(text, total, words);
+    if (allowance === 0 ? expected === total.minutes : Math.abs(expected - total.minutes) < allowance) return [];
+    return [{ count, length, total, expected }];
+  });

package/src/derived/stays.ts

@@ -0,0 +1,145 @@
+import type { Span } from "../plugin.ts";
+import { bySentence } from "./sentence-buckets.ts";
+import { calendarDateOf, dateOf, shifted } from "./date-arithmetic.ts";
+import type { DatedValue } from "./durations.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+
+/**
+ * 泊数。チェックインからチェックアウトまでの泊数は、二つの日付の差の日数（10月12日から10月14日までは2泊）。
+ * 一つの文に日付がちょうど二つと泊数がちょうど一つあるときと、チェックイン・チェックアウト・泊数の列がそろった表の行で比べる。
+ * 「2泊3日」のように泊数と日数を並べたものは、日数が泊数より一つ多いかを見る。Pure.
+ */
+export type Count = Span & { readonly amount: number };
+
+export type NightsMismatch = { readonly start: DatedValue; readonly end: DatedValue; readonly nights: Span; readonly expected: number };
+
+export type NightsDaysMismatch = { readonly nights: Count; readonly days: Count; readonly expected: number };
+
+export type StayColumnWords = {
+  readonly checkIn: readonly string[];
+  readonly checkOut: readonly string[];
+  readonly nights: readonly string[];
+  /** The words of a nights unit (泊, nights) a nights cell may write after its number. */
+  readonly units: readonly string[];
+};
+
+const DAY_MS = 86_400_000;
+
+type Between = { start: DatedValue; end: DatedValue; nights: number };
+
+const daysFrom = (from: Date, to: Date): number => Math.round((to.getTime() - from.getTime()) / DAY_MS);
+
+/** 月日だけの二つの日付は、近いほうの向き（12月30日と1月2日は年をまたいで3泊、10月14日と10月12日は2泊）。 */
+const nearerWay = (first: DatedValue, second: DatedValue, firstDay: Date, secondDay: Date): Between => {
+  const forward = daysFrom(firstDay, secondDay);
+  const ahead = forward < 0 ? daysFrom(firstDay, shifted(secondDay, 1, "year")) : forward;
+  const back = -forward < 0 ? daysFrom(secondDay, shifted(firstDay, 1, "year")) : -forward;
+  return back < ahead ? { start: second, end: first, nights: back } : { start: first, end: second, nights: ahead };
+};
+
+/** 二つの日付の間の泊数。年まで書いたら早いほうから。年の有る日付と無い日付の組は読まない。 */
+const nightsBetween = (first: DatedValue, second: DatedValue): Between | undefined => {
+  const [firstDate, secondDate] = [calendarDateOf(first.value), calendarDateOf(second.value)];
+  if (firstDate === undefined || secondDate === undefined || (firstDate.year === undefined) !== (secondDate.year === undefined)) return undefined;
+  const [firstDay, secondDay] = [dateOf(firstDate), dateOf(secondDate)];
+  if (firstDate.year === undefined) return nearerWay(first, second, firstDay, secondDay);
+  const forward = daysFrom(firstDay, secondDay);
+  return forward < 0 ? { start: second, end: first, nights: -forward } : { start: first, end: second, nights: forward };
+};
+
+const mismatchOf = (first: DatedValue, second: DatedValue, nights: Count): NightsMismatch | undefined => {
+  const between = nightsBetween(first, second);
+  if (between === undefined || between.nights <= 0 || between.nights === nights.amount) return undefined;
+  return { start: between.start, end: between.end, nights, expected: between.nights };
+};
+
+/** 一つの文の中の、二つの日付と泊数。 */
+export const stayNightsMismatches = (sentences: readonly Span[], dates: readonly DatedValue[], nights: readonly Count[]): NightsMismatch[] => {
+  const datesIn = bySentence(sentences, dates);
+  return [...bySentence(sentences, nights).entries()].flatMap(([index, inNights]) => {
+    const inDates = datesIn.get(index) ?? [];
+    const [first, second] = inDates;
+    const [count] = inNights;
+    if (inDates.length !== 2 || inNights.length !== 1 || first === undefined || second === undefined || count === undefined) return [];
+    const mismatch = mismatchOf(first, second, count);
+    return mismatch === undefined ? [] : [mismatch];
+  });
+};
+
+const normalizedGap = (text: string): string => text.normalize("NFKC").trim().toLowerCase().replace(/\s+/gu, " ");
+
+const joined = (source: string, left: Span, right: Span, joiners: readonly string[]): boolean => {
+  if (right.start < left.end) return false;
+  const gap = normalizedGap(source.slice(left.end, right.start));
+  return gap === "" || joiners.some((joiner) => normalizedGap(joiner) === gap);
+};
+
+/** 泊数と日数を並べたもの（2泊3日、2 days, 1 night）。泊数の直前か直後に、つなぎの語だけを挟んで日数がある。 */
+export const nightsDaysPairs = (
+  source: string,
+  nights: readonly Count[],
+  days: readonly Count[],
+  joiners: readonly string[],
+): { nights: Count; days: Count }[] =>
+  nights.flatMap((count) => {
+    const paired = days.find((day) => joined(source, count, day, joiners) || joined(source, day, count, joiners));
+    return paired === undefined ? [] : [{ nights: count, days: paired }];
+  });
+
+/** 日数が泊数より一つ多くない組。 */
+export const nightsDaysMismatches = (pairs: readonly { nights: Count; days: Count }[]): NightsDaysMismatch[] =>
+  pairs.flatMap((pair) => (pair.days.amount === pair.nights.amount + 1 ? [] : [{ ...pair, expected: pair.nights.amount + 1 }]));
+
+const keyOf = (text: string): string => withoutEdgeMarks(text).normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+
+const columnOf = (header: readonly Cell[], names: readonly string[]): number => {
+  const wanted = new Set(names.map(keyOf));
+  return header.findIndex((cell) => wanted.has(keyOf(cell.text)));
+};
+
+const LEADING_DIGITS = /^\d+/u;
+
+/** 泊数の升の数（「2」「2泊」「2 nights」）。それ以外を書いた升は読まない。 */
+const nightsInCell = (cell: Cell, units: readonly string[]): Count | undefined => {
+  const key = keyOf(cell.text);
+  const digits = LEADING_DIGITS.exec(key)?.[0];
+  if (digits === undefined) return undefined;
+  const rest = key.slice(digits.length).trim();
+  if (rest !== "" && !units.some((unit) => keyOf(unit) === rest)) return undefined;
+  const offset = cell.text.length - cell.text.trimStart().length;
+  return { start: cell.start + offset, end: cell.end, amount: Number(digits) };
+};
+
+const onlyDateIn = (cell: Cell | undefined, dates: readonly DatedValue[]): DatedValue | undefined => {
+  if (cell === undefined) return undefined;
+  const inside = dates.filter((date) => date.start >= cell.start && date.end <= cell.end);
+  return inside.length === 1 ? inside[0] : undefined;
+};
+
+type StayColumns = { readonly checkIn: number; readonly checkOut: number; readonly nights: number };
+
+const rowMismatch = (cells: readonly Cell[], columns: StayColumns, dates: readonly DatedValue[], units: readonly string[]): NightsMismatch | undefined => {
+  const checkIn = onlyDateIn(cells[columns.checkIn], dates);
+  const checkOut = onlyDateIn(cells[columns.checkOut], dates);
+  const nightsCell = cells[columns.nights];
+  const nights = nightsCell === undefined ? undefined : nightsInCell(nightsCell, units);
+  return checkIn === undefined || checkOut === undefined || nights === undefined ? undefined : mismatchOf(checkIn, checkOut, nights);
+};
+
+/** チェックイン・チェックアウト・泊数の列がある表の、行ごとの泊数。 */
+export const tableNightsMismatches = (source: string, dates: readonly DatedValue[], words: StayColumnWords): NightsMismatch[] =>
+  tablesOf(linesOf(source)).flatMap(({ header, rows }) => {
+    const headerCells = cellsOf(header);
+    const columns = {
+      checkIn: columnOf(headerCells, words.checkIn),
+      checkOut: columnOf(headerCells, words.checkOut),
+      nights: columnOf(headerCells, words.nights),
+    };
+    if (Object.values(columns).some((index) => index < 0)) return [];
+    return rows.flatMap((row) => {
+      const mismatch = rowMismatch(cellsOf(row), columns, dates, words.units);
+      return mismatch === undefined ? [] : [mismatch];
+    });
+  });

package/src/derived/time-lengths.ts

@@ -0,0 +1,226 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { isWordAt, wordOffsets, type Mark } from "../structure/time-marks.ts";
+import { linesOf } from "../structure/lines.ts";
+
+/**
+ * Lengths of time in hours and minutes (8時間, 7時間30分, 90分, 1-hour, one-hour, 7.5 hours), the words written beside
+ * them (実働8時間, 8 hours a day), and the stretches of text a statement of hours is read in. The words come from the
+ * language packages; nothing here knows a language. Pure.
+ */
+export type TimeLength = Span & {
+  readonly minutes: number;
+  /** The smallest unit the length is written in, in minutes: 60 for 24時間, 1 for 90分 or 7時間30分, 30 for 7時間半. */
+  readonly unit: number;
+};
+
+export type LengthWords = {
+  readonly hourUnits: readonly string[];
+  readonly minuteUnits: readonly string[];
+  /** What written right after the hour unit adds half an hour (7時間半). */
+  readonly halves: readonly string[];
+  /** Numbers written as words, in order from one. */
+  readonly numberWords: readonly string[];
+};
+
+const MINUTES_PER_HOUR = 60;
+const HALF_HOUR = 30;
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .filter((word) => word !== "")
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+const LATIN_END = /[a-z]$/iu;
+const LATIN_START = /^[a-z]/iu;
+
+const numberOf = (written: string, numberWords: readonly string[]): number => {
+  const position = numberWords.findIndex((word) => word.toLowerCase() === written.toLowerCase());
+  return position >= 0 ? position + 1 : Number(written.normalize("NFKC"));
+};
+
+/** A digit number not inside a longer one, or a number word standing as a word of its own. */
+const numberPattern = (numberWords: readonly string[]): string => {
+  const words = alternation(numberWords);
+  const digits = "(?<![\\p{N}.,．/⁄])(\\p{Nd}+(?:[.．]\\p{Nd}+)?)";
+  return words === "" ? digits : `(?:${digits}|(?<![\\p{L}\\p{N}\\p{Pd}])(${words}))`;
+};
+
+const SEPARATOR = "[\\s\\-‐]?";
+
+type Read = { readonly span: Span; readonly minutes: number; readonly unit: number };
+
+/** A Latin unit runs on into a longer word ("8 hoursx") or a letter-led tail: not a length. */
+const runsOn = (text: string, end: number): boolean => LATIN_END.test(text.slice(end - 1, end)) && LATIN_START.test(text.charAt(end));
+
+const DECIMAL_BASE = 10;
+
+/** 7.5 hours is written to a tenth of an hour, 6 minutes. */
+const hourStep = (number: string | undefined): number => {
+  const decimals = (number ?? "").normalize("NFKC").split(".")[1]?.length ?? 0;
+  return MINUTES_PER_HOUR / DECIMAL_BASE ** decimals;
+};
+
+const smallestUnit = (number: string | undefined, minutes: string | undefined, half: string | undefined): number => {
+  if (minutes !== undefined) return 1;
+  return half === undefined ? hourStep(number) : Math.min(HALF_HOUR, hourStep(number));
+};
+
+const hourLengths = (text: string, words: LengthWords): Read[] => {
+  const [hours, minutes, halves] = [alternation(words.hourUnits), alternation(words.minuteUnits), alternation(words.halves)];
+  if (hours === "") return [];
+  const minutePart = minutes === "" ? "" : `|\\s?(\\p{Nd}{1,2})\\s?(?:${minutes})`;
+  const halfPart = halves === "" ? "" : `|\\s?(${halves})`;
+  const tail = minutePart === "" && halfPart === "" ? "" : `(?:${minutePart.slice(1)}${halfPart})?`;
+  const pattern = new RegExp(`${numberPattern(words.numberWords)}${SEPARATOR}(?:${hours})${tail}`, "giu");
+  return [...text.matchAll(pattern)].flatMap((match): Read[] => {
+    const end = match.index + match[0].length;
+    if (runsOn(text, end)) return [];
+    const amount = numberOf(match[1] ?? match[2] ?? "", words.numberWords);
+    const extra = match[3] === undefined ? 0 : Number(match[3].normalize("NFKC"));
+    const half = match[4] === undefined ? 0 : HALF_HOUR;
+    return [{ span: { start: match.index, end }, minutes: amount * MINUTES_PER_HOUR + extra + half, unit: smallestUnit(match[1], match[3], match[4]) }];
+  });
+};
+
+const minuteLengths = (text: string, words: LengthWords): Read[] => {
+  const minutes = alternation(words.minuteUnits);
+  if (minutes === "") return [];
+  const pattern = new RegExp(`${numberPattern(words.numberWords)}${SEPARATOR}(?:${minutes})`, "giu");
+  return [...text.matchAll(pattern)].flatMap((match): Read[] => {
+    const end = match.index + match[0].length;
+    return runsOn(text, end) ? [] : [{ span: { start: match.index, end }, minutes: numberOf(match[1] ?? match[2] ?? "", words.numberWords), unit: 1 }];
+  });
+};
+
+const overlaps = (left: Span, right: Span): boolean => left.start < right.end && right.start < left.end;
+
+/** Lengths of time in hours and minutes, in the order written. A minutes-only reading inside an hours one is dropped. */
+export const timeLengths = (text: string, words: LengthWords): TimeLength[] => {
+  const hours = hourLengths(text, words);
+  const minutes = minuteLengths(text, words).filter((read) => !hours.some((hour) => overlaps(hour.span, read.span)));
+  return [...hours, ...minutes]
+    .filter((read) => Number.isFinite(read.minutes) && read.minutes > 0)
+    .map((read) => ({ ...read.span, minutes: read.minutes, unit: read.unit }))
+    .toSorted((left, right) => left.start - right.start);
+};
+
+const longestFirst = (marks: readonly Mark[]): Mark[] => marks.toSorted((left, right) => right.pattern.length - left.pattern.length);
+
+const LABEL_GAP_BEFORE = new Set([" ", "\t", "\u3000", ":", "："]);
+const LABEL_GAP_AFTER = /^\s*/u;
+const LOOK_AROUND = 40;
+
+const lower = (text: string): string => text.toLowerCase();
+
+/** Where the separators that may stand between a label and its length (休憩：1時間、Break: 1 hour) begin, reading back from at. */
+const gapStart = (text: string, at: number): number => {
+  let start = at;
+  while (start > 0 && LABEL_GAP_BEFORE.has(text.charAt(start - 1))) start -= 1;
+  return start;
+};
+
+/** Whether pattern is written as a word at offset at, case aside. Reads a window around it, not the whole text. */
+const isLabelAt = (text: string, at: number, pattern: string): boolean => {
+  if (at < 0) return false;
+  const from = Math.max(0, at - 1);
+  return isWordAt(lower(text.slice(from, at + pattern.length + 1)), at - from, lower(pattern));
+};
+
+/** The label written right before span (after separators only), or undefined. */
+const labelBefore = (text: string, span: Span, marks: readonly Mark[]): Span | undefined => {
+  const end = gapStart(text, span.start);
+  if (span.start - end > LOOK_AROUND) return undefined;
+  const found = longestFirst(marks.filter((mark) => (mark.position ?? "before") === "before")).find((mark) =>
+    isLabelAt(text, end - mark.pattern.length, mark.pattern),
+  );
+  return found === undefined ? undefined : { start: end - found.pattern.length, end };
+};
+
+/** The label written right after span (after white space only), or undefined. */
+const labelAfter = (text: string, span: Span, marks: readonly Mark[]): Span | undefined => {
+  const start = span.end + (LABEL_GAP_AFTER.exec(text.slice(span.end, span.end + LOOK_AROUND))?.[0].length ?? 0);
+  const found = longestFirst(marks.filter((mark) => mark.position === "after")).find((mark) => isLabelAt(text, start, mark.pattern));
+  return found === undefined ? undefined : { start, end: start + found.pattern.length };
+};
+
+/** The label beside span, before or after it. */
+export const labelOf = (text: string, span: Span, marks: readonly Mark[]): Span | undefined => labelBefore(text, span, marks) ?? labelAfter(text, span, marks);
+
+/** Where the words of marks are written inside scope. */
+export const mentionsIn = (text: string, scope: Span, marks: readonly Mark[]): Span[] => {
+  const inside = lower(text.slice(scope.start, scope.end));
+  return [...new Set(marks.map((mark) => lower(mark.pattern)))].flatMap((pattern) =>
+    wordOffsets(inside, pattern).map((at) => ({ start: scope.start + at, end: scope.start + at + pattern.length })),
+  );
+};
+
+export const within = (inner: Span, outer: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
+
+const LIST_ITEM = /^\s*(?:[-*+・•]|\d{1,3}[.)])\s/u;
+
+type Paragraph = { readonly span: Span; readonly lines: readonly Span[]; readonly listed: boolean };
+
+type Run = { readonly lines: Span[]; listed: boolean };
+
+/** Runs of non-blank lines. listed: every line of the run is a list item in the source. */
+const paragraphsOf = (text: string, source: string): Paragraph[] => {
+  const listedLines = linesOf(source).map((line) => LIST_ITEM.test(line.text));
+  const runs: Run[] = [{ lines: [], listed: true }];
+  linesOf(text).forEach((line, index) => {
+    const run = runs[runs.length - 1];
+    if (line.text.trim() === "") runs.push({ lines: [], listed: true });
+    else if (run !== undefined) {
+      run.lines.push({ start: line.start, end: line.start + line.text.length });
+      run.listed = run.listed && listedLines[index] === true;
+    }
+  });
+  return runs.flatMap(({ lines, listed }) => {
+    const [first, last] = [lines[0], lines[lines.length - 1]];
+    return first === undefined || last === undefined ? [] : [{ span: { start: first.start, end: last.end }, lines, listed }];
+  });
+};
+
+const clipped = (inner: Span, outer: Span): Span => ({ start: Math.max(inner.start, outer.start), end: Math.min(inner.end, outer.end) });
+
+/** A sentence that ends on a clock time ("5:30 p.m. (a one-hour break") runs on into the next. */
+const joinedAtTimes = (sentences: readonly Span[], times: readonly Span[]): Span[] =>
+  sentences.reduce<Span[]>((joined, sentence) => {
+    const last = joined[joined.length - 1];
+    if (last !== undefined && times.some((time) => time.start < last.end && last.end <= time.end)) {
+      joined[joined.length - 1] = { start: last.start, end: sentence.end };
+    } else joined.push(sentence);
+    return joined;
+  }, []);
+
+/** The sentences of a line, clipped to it; the line itself when no sentence lies on it. */
+const sentencesOn = (line: Span, sentences: readonly Span[]): Span[] => {
+  const on = sentences.filter((sentence) => overlaps(sentence, line)).map((sentence) => clipped(sentence, line));
+  return on.length === 0 ? [line] : on;
+};
+
+/**
+ * The stretches a statement is read in: each sentence of a line, and a list whose items say it together (勤務時間 /
+ * 休憩 / 実働 on three items). read returns undefined when a stretch does not hold exactly one statement; a list that
+ * reads as one is not read again line by line.
+ */
+export const readScopes = <T>(
+  text: string,
+  source: string,
+  split: { readonly sentences: readonly Span[]; readonly times: readonly Span[] },
+  read: (scope: Span) => T | undefined,
+): T[] => {
+  const sentences = joinedAtTimes(split.sentences, split.times);
+  return paragraphsOf(text, source).flatMap((paragraph) => {
+    const whole = paragraph.listed && paragraph.lines.length > 1 ? read(paragraph.span) : undefined;
+    if (whole !== undefined) return [whole];
+    return paragraph.lines.flatMap((line) =>
+      sentencesOn(line, sentences).flatMap((scope) => {
+        const result = read(scope);
+        return result === undefined ? [] : [result];
+      }),
+    );
+  });
+};

package/src/derived/unit-counts.ts

@@ -0,0 +1,18 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+export type UnitCount = Span & { readonly amount: number };
+
+const LATIN_UNIT = /^[a-z]+$/iu;
+
+/** 数字と単位（3泊、3 nights、15回）。英字の単位は語の切れ目まで。Pure. */
+export const numeralCounts = (text: string, units: readonly string[]): UnitCount[] =>
+  units.flatMap((unit) => {
+    const tail = LATIN_UNIT.test(unit) ? "(?![\\p{L}\\p{N}])" : "";
+    const pattern = new RegExp(`(?<![\\p{N}.,])(\\p{Nd}+)\\s?${escapeRegExp(unit)}${tail}`, "giu");
+    return [...text.matchAll(pattern)].map((match) => ({
+      start: match.index,
+      end: match.index + match[0].length,
+      amount: Number((match[1] ?? "").normalize("NFKC")),
+    }));
+  });