chaffjs 0.30.0 → 0.32.0

package/src/derived/period-parts.ts

@@ -0,0 +1,360 @@
+import type { Span } from "../plugin.ts";
+import type { DurationUnit } from "./date-arithmetic.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 期間の一部として書いた期間（「保証期間（12か月）のうち、無料交換期間は18か月」"Within the 12-month warranty period, the free
+ * replacement period is 18 months"）が、全体より長い所。全体の長さは、印の前後に書いた長さ（括弧の中、名詞の前）を読み、無ければ
+ * 同じ節で全体の名前（保証期間）に書いた長さを読む。「このうち」"within it" は前の文の長さ。目安の長さ、幅のある長さ、延長や追加の期間
+ * （全体の後に来る期間）は比べない。年と月、週と日の間だけ換算する。
+ */
+export type PeriodLength = Span & { readonly amount: number; readonly unit: DurationUnit };
+
+/** 全体と部分をつなぐ印。position は全体から見た印の側（のうち は全体の後ろ after、within the は前 before）。 */
+export type PartMarker = { readonly pattern: string; readonly position: "before" | "after"; readonly group?: string | undefined };
+
+export type PlacedWord = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type PeriodPartWords = {
+  readonly markers: readonly PartMarker[];
+  /** 期間の名前の終わりの語（期間、period）。 */
+  readonly periodWords: readonly string[];
+  /** 全体の後に来る期間の語（延長、extended）。文にあれば読まない。 */
+  readonly afterWords: readonly string[];
+  /** 名前の後ろで長さを言う語（the warranty runs for 12 months の runs for）。 */
+  readonly lengthVerbs: readonly string[];
+  readonly approximate: readonly PlacedWord[];
+  readonly rangeJoiners: readonly string[];
+  /** 長さと名前の間に置く語（12か月の保証期間 の の）。空白だけの間はいつでもよい。 */
+  readonly inlineJoiners: readonly string[];
+  /** 期間の語の前に来ても名前にならない語（the period、that period）。 */
+  readonly unnamed: readonly string[];
+};
+
+export type PeriodPartIssue = { readonly part: PeriodLength; readonly whole: PeriodLength };
+
+/** 印の group。anaphor は前の文の期間を全体にする（このうち）。adjacent は部分を印のすぐ前に書く（18 months of the warranty）。 */
+const ANAPHOR = "anaphor";
+const ADJACENT = "adjacent";
+
+type Whole = { readonly phrase: Span; readonly label: string; readonly inline: PeriodLength | undefined };
+
+const NEAR = 12;
+const JA_LABEL_CHAR = /^[\p{Script=Han}\p{Script=Katakana}ー]$/u;
+
+/** text の終わりの、漢字と片仮名の続き（「本体の保証期間」の 保証期間）。 */
+const labelRunAtEnd = (text: string): string => {
+  let start = text.length;
+  while (start > 0 && JA_LABEL_CHAR.test(text.charAt(start - 1))) start -= 1;
+  return text.slice(start);
+};
+
+/** text の頭の、漢字と片仮名の続き（「無料修理期間は」の 無料修理期間）。 */
+const labelRunAtStart = (text: string): string => {
+  let end = 0;
+  while (end < text.length && JA_LABEL_CHAR.test(text.charAt(end))) end += 1;
+  return text.slice(0, end);
+};
+
+/** text の終わりの語（"the free replacement " の replacement）。 */
+const wordAtEnd = (text: string): string => {
+  const trimmed = text.trimEnd();
+  let start = trimmed.length;
+  while (start > 0 && LETTER.test(trimmed.charAt(start - 1))) start -= 1;
+  return trimmed.slice(start);
+};
+const LETTER = /\p{L}/u;
+const BRACKET_PAIRS: Readonly<Record<string, string>> = { "）": "（", ")": "(" };
+const MONTHS_PER_YEAR = 12;
+const DAYS_PER_WEEK = 7;
+
+const lower = (text: string): string => text.toLowerCase();
+const includesWord = (text: string, words: readonly string[]): boolean => words.some((word) => word !== "" && lower(text).includes(lower(word)));
+
+const BARE_NUMBER = /\p{Nd}$/u;
+
+/** 幅の端（12〜18か月、12 to 18 months、12か月から18か月）。つなぐ語の向こうに数だけか、別の長さがある。 */
+const isRange = (source: string, length: Span, lengths: readonly Span[], joiners: readonly string[]): boolean =>
+  joiners.some((joiner) => {
+    if (joiner === "") return false;
+    const before = lower(source.slice(Math.max(0, length.start - NEAR), length.start).trimEnd());
+    const head = before.endsWith(lower(joiner)) ? source.slice(0, length.start).trimEnd().slice(0, -joiner.length).trimEnd() : undefined;
+    const opens = head !== undefined && (BARE_NUMBER.test(head) || lengths.some((other) => other.end === head.length));
+    const after = source.slice(length.end, length.end + NEAR);
+    const rest = after.trimStart();
+    const tail = rest.slice(joiner.length);
+    const tailAt = length.end + (after.length - rest.length) + joiner.length + (tail.length - tail.trimStart().length);
+    const closes = lower(rest).startsWith(lower(joiner)) && lengths.some((other) => other.start === tailAt);
+    return opens || closes;
+  });
+
+/** 約18か月、18か月程度、up to 18 months、12〜18か月、12 to 18 months。 */
+const isRough = (source: string, length: Span, lengths: readonly Span[], words: PeriodPartWords): boolean => {
+  const before = lower(source.slice(Math.max(0, length.start - NEAR), length.start).trimEnd());
+  const after = lower(source.slice(length.end, length.end + NEAR).trimStart());
+  const marked = words.approximate.some((word) => (word.position === "before" ? before.endsWith(lower(word.pattern)) : after.startsWith(lower(word.pattern))));
+  return marked || isRange(source, length, lengths, words.rangeJoiners);
+};
+
+const within = (span: Span, outer: Span): boolean => span.start >= outer.start && span.end <= outer.end;
+const lengthsIn = (lengths: readonly PeriodLength[], span: Span): PeriodLength[] => lengths.filter((length) => within(length, span));
+
+/** 名前のすぐ前に書いた長さ（12か月の保証期間、12-month warranty period）。 */
+const lengthJustBefore = (source: string, lengths: readonly PeriodLength[], at: number, joiners: readonly string[]): PeriodLength | undefined =>
+  lengths.find((length) => {
+    const gap = source.slice(length.end, at).trim();
+    return length.end <= at && (gap === "" || joiners.includes(gap));
+  });
+
+const endsWithPeriodWord = (label: string, words: PeriodPartWords): boolean =>
+  words.periodWords.some((word) => word !== "" && lower(label).endsWith(lower(word)) && label.length > word.length);
+
+/** 括弧の始まり（「保証期間（12か月）」の （）。閉じ括弧で終わらなければ undefined。 */
+const bracketStart = (source: string, start: number, end: number): number | undefined => {
+  const opener = BRACKET_PAIRS[source.charAt(end - 1)];
+  if (opener === undefined) return undefined;
+  const at = source.lastIndexOf(opener, end - 1);
+  return at >= start ? at : undefined;
+};
+
+/** 全体を印の前に書いたもの（保証期間（12か月）のうち）。名前は漢字と片仮名の続き。 */
+const wholeBefore = (source: string, unit: Span, markerAt: number, lengths: readonly PeriodLength[], words: PeriodPartWords): Whole | undefined => {
+  const bracket = bracketStart(source, unit.start, markerAt);
+  const labelEnd = bracket ?? markerAt;
+  const label = labelRunAtEnd(source.slice(unit.start, labelEnd));
+  if (!endsWithPeriodWord(label, words)) return undefined;
+  const labelStart = labelEnd - label.length;
+  const inBracket = bracket === undefined ? [] : lengthsIn(lengths, { start: bracket, end: markerAt });
+  const inline = inBracket[0] ?? lengthJustBefore(source, lengths, labelStart, words.inlineJoiners);
+  return { phrase: { start: inline === undefined ? labelStart : Math.min(inline.start, labelStart), end: markerAt }, label, inline };
+};
+
+const labelPattern = (words: PeriodPartWords): RegExp => {
+  const ends = words.periodWords
+    .filter((word) => word !== "")
+    .map(escapeRegExp)
+    .join("|");
+  return new RegExp(`^((?:\\p{L}+ ){0,3}?(?:${ends}))(?!\\p{L})(\\s*\\([^)]*\\))?`, "iu");
+};
+
+/** 全体を印の後ろに書いたもの（within the 12-month warranty period、within the warranty period (12 months)）。 */
+const wholeAfter = (source: string, unit: Span, markerEnd: number, lengths: readonly PeriodLength[], words: PeriodPartWords): Whole | undefined => {
+  const gap = source.slice(markerEnd, unit.end).length - source.slice(markerEnd, unit.end).trimStart().length;
+  const lead = lengths.find((length) => length.start === markerEnd + gap);
+  const afterLead = lead === undefined ? "" : source.slice(lead.end, unit.end);
+  const labelAt = lead === undefined ? markerEnd + gap : lead.end + afterLead.length - afterLead.trimStart().length;
+  const match = labelPattern(words).exec(source.slice(labelAt, unit.end));
+  if (words.periodWords.length === 0 || match === null) return undefined;
+  const end = labelAt + match[0].length;
+  const inBracket = lengthsIn(lengths, { start: labelAt + (match[1] ?? "").length, end });
+  return { phrase: { start: markerEnd, end }, label: match[1] ?? "", inline: lead ?? inBracket[0] };
+};
+
+const occurrences = (text: string, pattern: string): number[] => {
+  const found: number[] = [];
+  let at = text.indexOf(pattern);
+  while (pattern !== "" && at !== -1) {
+    found.push(at);
+    at = text.indexOf(pattern, at + pattern.length);
+  }
+  return found;
+};
+
+type MarkerAt = { readonly marker: PartMarker; readonly start: number; readonly end: number };
+
+const LATIN = /[a-z]/iu;
+
+/** 英字の印は語の途中で切らない（within the の前後が英字なら別の語）。 */
+const cutsWord = (source: string, start: number, end: number, pattern: string): boolean =>
+  LATIN.test(pattern) && (LETTER.test(source.charAt(start - 1)) || LETTER.test(source.charAt(end)));
+
+const markersIn = (source: string, unit: Span, markers: readonly PartMarker[]): MarkerAt[] => {
+  const text = lower(source.slice(unit.start, unit.end));
+  return markers.flatMap((marker) =>
+    occurrences(text, lower(marker.pattern))
+      .map((at) => ({ marker, start: unit.start + at, end: unit.start + at + marker.pattern.length }))
+      .filter((found) => !cutsWord(source, found.start, found.end, marker.pattern)),
+  );
+};
+
+export type PeriodPartInput = {
+  readonly source: string;
+  /** 文と表の行。出てくる順。 */
+  readonly units: readonly Span[];
+  /** 節の始まり（見出しの位置）。 */
+  readonly sectionStarts: readonly number[];
+  readonly lengths: readonly PeriodLength[];
+  readonly words: PeriodPartWords;
+};
+
+/** 昇順の節の始まりのうち、at 以前のものの数（二分探索）。大きな文書で節を引くたびに見出しを全部回らないため。 */
+const sectionOf = (starts: readonly number[], at: number): number => {
+  let low = 0;
+  let high = starts.length;
+  while (low < high) {
+    const middle = (low + high) >> 1;
+    if ((starts[middle] ?? Number.POSITIVE_INFINITY) <= at) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+};
+
+/** 年は月に、週は日に揃える。月と日の間は月の日数が決まらないので比べない。 */
+const scaleOf = (length: PeriodLength): { readonly family: string; readonly amount: number } => {
+  if (length.unit === "year") return { family: "month", amount: length.amount * MONTHS_PER_YEAR };
+  if (length.unit === "week") return { family: "day", amount: length.amount * DAYS_PER_WEEK };
+  return { family: length.unit, amount: length.amount };
+};
+
+const isLonger = (part: PeriodLength, whole: PeriodLength): boolean => {
+  const [left, right] = [scaleOf(part), scaleOf(whole)];
+  return left.family === right.family && left.amount > right.amount;
+};
+
+/** 名前の前が同じ語の続き（無料修理期間の 修理期間、extended warranty period）なら、別の期間の名前。 */
+const isWholeName = (source: string, at: number, label: string, words: PeriodPartWords): boolean => {
+  const before = source.charAt(at - 1);
+  const joined = JA_LABEL_CHAR.test(before) && JA_LABEL_CHAR.test(label.charAt(0));
+  const inWord = LETTER.test(before) && LATIN.test(label.charAt(0));
+  return !joined && !inWord && !includesWord(source.slice(Math.max(0, at - NEAR), at), words.afterWords);
+};
+
+/** 一つの文か行で、全体の名前の後ろに書いた長さ。名前の後ろに長さが一つだけのとき。 */
+const statedLength = (input: PeriodPartInput, unit: Span, label: string): PeriodLength | undefined => {
+  const { source, lengths, words } = input;
+  const named = occurrences(lower(source.slice(unit.start, unit.end)), lower(label))
+    .map((at) => unit.start + at)
+    .find((at) => isWholeName(source, at, label, words));
+  if (named === undefined) return undefined;
+  const after = lengthsIn(lengths, { start: named + label.length, end: unit.end });
+  const [only] = after;
+  return after.length === 1 && only !== undefined && !isRough(source, only, lengths, words) ? only : undefined;
+};
+
+/** the warranty runs for 12 months: 名前から期間の語を除いた語、長さを言う語、長さが続けて並ぶ。 */
+const verbLength = (input: PeriodPartInput, unit: Span, label: string): PeriodLength | undefined => {
+  const { source, lengths, words } = input;
+  const end = words.periodWords.find((word) => lower(label).endsWith(lower(word)));
+  const stem = end === undefined ? "" : label.slice(0, -end.length).trim();
+  if (stem === "") return undefined;
+  const text = lower(source.slice(unit.start, unit.end));
+  return words.lengthVerbs.flatMap((verb) => {
+    const phrase = lower(`${stem} ${verb}`);
+    return occurrences(text, phrase).flatMap((at) => {
+      const from = unit.start + at + phrase.length;
+      const next = lengths.find((length) => length.start >= from && source.slice(from, length.start).trim() === "");
+      return next === undefined || isRough(source, next, lengths, words) ? [] : [next];
+    });
+  })[0];
+};
+
+const hasMarker = (input: PeriodPartInput, unit: Span): boolean => markersIn(input.source, unit, input.words.markers).length > 0;
+
+/** 同じ節で全体の名前に書いた長さ。違う長さが並べば一番長いもの（どれより長いときだけ言う）。 */
+const wholeInSection = (input: PeriodPartInput, current: Span, label: string): PeriodLength[] => {
+  const section = sectionOf(input.sectionStarts, current.start);
+  return input.units
+    .filter((unit) => unit !== current && sectionOf(input.sectionStarts, unit.start) === section && !hasMarker(input, unit))
+    .flatMap((unit) => {
+      const stated = statedLength(input, unit, label) ?? verbLength(input, unit, label);
+      return stated === undefined ? [] : [stated];
+    });
+};
+
+/** このうち: すぐ前の文が、期間の語と長さ一つを持つとき、その長さ。 */
+const previousWhole = (input: PeriodPartInput, index: number): PeriodLength[] => {
+  const [previous, current] = [input.units[index - 1], input.units[index]];
+  if (previous === undefined || current === undefined) return [];
+  if (sectionOf(input.sectionStarts, previous.start) !== sectionOf(input.sectionStarts, current.start)) return [];
+  const inPrevious = lengthsIn(input.lengths, previous);
+  const [only] = inPrevious;
+  const named = includesWord(input.source.slice(previous.start, previous.end), input.words.periodWords);
+  return inPrevious.length === 1 && only !== undefined && named && !isRough(input.source, only, input.lengths, input.words) ? [only] : [];
+};
+
+const wholeOf = (input: PeriodPartInput, unit: Span, found: MarkerAt): Whole | undefined =>
+  found.marker.position === "after"
+    ? wholeBefore(input.source, unit, found.start, input.lengths, input.words)
+    : wholeAfter(input.source, unit, found.end, input.lengths, input.words);
+
+/**
+ * 全体と別の名前の付いた期間（無料交換期間、the free replacement period）。the period of 21 days のような名前の無い期間と、全体の名前を
+ * もう一度書いたもの（submit the warranty period claim form）は部分と読まない。
+ */
+const namesPeriod = (text: string, words: PeriodPartWords, wholeLabel: string): boolean =>
+  words.periodWords.some((word) =>
+    occurrences(lower(text), lower(word)).some((at) => {
+      const upTo = text.slice(0, at + word.length);
+      if (LATIN.test(word)) {
+        const before = wordAtEnd(text.slice(0, at));
+        const named = before !== "" && !LETTER.test(text.charAt(at - 1)) && !words.unnamed.some((unnamed) => lower(unnamed) === lower(before));
+        return named && (wholeLabel === "" || !lower(upTo).endsWith(lower(wholeLabel)));
+      }
+      return JA_LABEL_CHAR.test(text.charAt(at - 1)) && labelRunAtEnd(upTo) !== wholeLabel;
+    }),
+  );
+
+/** 部分の長さ: 全体の句の外に長さがちょうど一つ。adjacent の印では印のすぐ前、他は全体の外に期間の語があること。 */
+const partOf = (input: PeriodPartInput, unit: Span, whole: Whole, found: MarkerAt): PeriodLength | undefined => {
+  const { phrase } = whole;
+  const { source, words } = input;
+  const outside = lengthsIn(input.lengths, unit).filter((length) => length.end <= phrase.start || length.start >= phrase.end);
+  const [part] = outside;
+  if (outside.length !== 1 || part === undefined || isRough(source, part, input.lengths, words)) return undefined;
+  if (found.marker.group === ADJACENT) return source.slice(part.end, found.start).trim() === "" ? part : undefined;
+  const rest = source.slice(unit.start, phrase.start) + source.slice(phrase.end, unit.end);
+  return namesPeriod(rest, words, whole.label) ? part : undefined;
+};
+
+const CLAUSE_COMMAS = ["、", "，", ","];
+
+/**
+ * 全体の句が節を開く（保証期間のうち、… / Within the warranty period, …）。前に置く印は文の頭で句の後ろに読点、後ろに置く印は
+ * すぐ後ろが読点か期間の名前（保証期間内の無料修理期間）。Claims arising within the 12-month warranty period are subject to a
+ * limitation period of 18 months の句は請求を修飾していて、制限期間はその一部ではない。
+ */
+const opensClause = (input: PeriodPartInput, unit: Span, phrase: Span, found: MarkerAt): boolean => {
+  const { source, words } = input;
+  if (found.marker.position === "before") {
+    const followedByComma = CLAUSE_COMMAS.some((comma) => source.slice(phrase.end).trimStart().startsWith(comma));
+    return source.slice(unit.start, found.start).trim() === "" && followedByComma;
+  }
+  const after = source.slice(found.end, unit.end);
+  return CLAUSE_COMMAS.some((comma) => after.startsWith(comma)) || endsWithPeriodWord(labelRunAtStart(after), words);
+};
+
+const issuesAt = (input: PeriodPartInput, index: number, found: MarkerAt): PeriodPartIssue[] => {
+  const unit = input.units[index];
+  if (unit === undefined) return [];
+  const anaphor = found.marker.group === ANAPHOR;
+  const whole = anaphor ? { phrase: { start: found.start, end: found.end }, label: "", inline: undefined } : wholeOf(input, unit, found);
+  if (whole === undefined || (found.marker.group !== ADJACENT && !opensClause(input, unit, whole.phrase, found))) return [];
+  const part = partOf(input, unit, whole, found);
+  if (part === undefined) return [];
+  const inlineWholes = whole.inline === undefined || isRough(input.source, whole.inline, input.lengths, input.words) ? [] : [whole.inline];
+  const named = whole.inline === undefined ? wholeInSection(input, unit, whole.label) : inlineWholes;
+  const wholes = anaphor ? previousWhole(input, index) : named;
+  const [first] = wholes;
+  if (first === undefined || !wholes.every((candidate) => isLonger(part, candidate))) return [];
+  const longest = wholes.reduce((left, right) => (scaleOf(right).amount > scaleOf(left).amount ? right : left), first);
+  return [{ part, whole: longest }];
+};
+
+/** 全体より長い部分の期間。一つの文に印が二つあっても、言うのは一度。 */
+export const periodPartIssues = (input: PeriodPartInput): PeriodPartIssue[] =>
+  input.units.flatMap((unit, index) => {
+    if (includesWord(input.source.slice(unit.start, unit.end), input.words.afterWords)) return [];
+    const [issue] = markersIn(input.source, unit, input.words.markers).flatMap((found) => issuesAt(input, index, found));
+    return issue === undefined ? [] : [issue];
+  });
+
+const TABLE_ROW = /^\s*\|.*\|\s*$/u;
+const TABLE_RULE = /^[\s|:-]+$/u;
+
+const LINE = /^[^\n]*$/gmu;
+
+/** 表の行（| 保証期間 | 1年 |）。区切りの行は除く。 */
+export const tableRowsOf = (source: string): Span[] =>
+  [...source.matchAll(LINE)].flatMap((line) =>
+    TABLE_ROW.test(line[0]) && !TABLE_RULE.test(line[0]) ? [{ start: line.index, end: line.index + line[0].length }] : [],
+  );

package/src/derived/readable-date.ts

@@ -0,0 +1,63 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * A date chaff computed or read into a value (2026-06-30, 06-30, 2026-06), written for a message the way a reader writes it:
+ * 2026年6月30日, June 30, 2026, or 30 June 2026 when the document writes its English dates day first. Text a message quotes
+ * from the document never comes through here: it stays as written. Pure.
+ */
+export type DayOrder = "month-first" | "day-first";
+
+/** months: the month names, January first. A language without them (or with fewer than twelve) keeps the value as it is. */
+export type DateWords = { readonly language: string; readonly months: readonly string[]; readonly order: DayOrder };
+
+type DateParts = { readonly year: string | undefined; readonly month: number; readonly day: number | undefined };
+
+const FULL = /^(\d{4})-(\d{2})-(\d{2})$/u;
+const MONTH_DAY = /^(\d{2})-(\d{2})$/u;
+const YEAR_MONTH = /^(\d{4})-(\d{2})$/u;
+const MONTHS_IN_YEAR = 12;
+const LAST_DAY = 31;
+
+const partsOf = (value: string): DateParts | undefined => {
+  const full = FULL.exec(value);
+  if (full !== null) return { year: full[1], month: Number(full[2]), day: Number(full[3]) };
+  const monthDay = MONTH_DAY.exec(value);
+  if (monthDay !== null) return { year: undefined, month: Number(monthDay[1]), day: Number(monthDay[2]) };
+  const yearMonth = YEAR_MONTH.exec(value);
+  return yearMonth === null ? undefined : { year: yearMonth[1], month: Number(yearMonth[2]), day: undefined };
+};
+
+const inRange = (parts: DateParts): boolean =>
+  parts.month >= 1 && parts.month <= MONTHS_IN_YEAR && (parts.day === undefined || (parts.day >= 1 && parts.day <= LAST_DAY));
+
+const japanese = ({ year, month, day }: DateParts): string =>
+  [year === undefined ? "" : `${year}年`, `${String(month)}月`, day === undefined ? "" : `${String(day)}日`].join("");
+
+const english = ({ year, day }: DateParts, name: string, order: DayOrder): string => {
+  if (day === undefined) return `${name} ${year ?? ""}`.trim();
+  if (order === "day-first") return [String(day), name, ...(year === undefined ? [] : [year])].join(" ");
+  return year === undefined ? `${name} ${String(day)}` : `${name} ${String(day)}, ${year}`;
+};
+
+/** The value as a reader writes the date; a value that is not a date (or a language without month names) is returned unchanged. */
+export const readableDate = (value: string, words: DateWords): string => {
+  const parts = partsOf(value);
+  if (parts === undefined || !inRange(parts)) return value;
+  if (words.language === "ja") return japanese(parts);
+  const name = words.months.length >= MONTHS_IN_YEAR ? words.months[parts.month - 1] : undefined;
+  return name === undefined ? value : english(parts, name, words.order);
+};
+
+/**
+ * Whether the document writes its English dates day first ("30 June 2026") rather than month first ("June 30, 2026"): the
+ * order more of its written dates take. A tie, or no English date at all, is month first.
+ */
+export const dayOrderOf = (written: readonly string[], monthWords: readonly string[]): DayOrder => {
+  if (monthWords.length === 0) return "month-first";
+  const names = monthWords.map(escapeRegExp).join("|");
+  const dayFirst = new RegExp(`(?:^|[^\\d])\\d{1,2}(?:st|nd|rd|th)?\\s+(?:${names})\\b`, "u");
+  const monthFirst = new RegExp(`\\b(?:${names})\\.?\\s+\\d{1,2}(?!\\d)`, "u");
+  const dayFirstCount = written.filter((text) => dayFirst.test(text) && !monthFirst.test(text)).length;
+  const monthFirstCount = written.filter((text) => monthFirst.test(text) && !dayFirst.test(text)).length;
+  return dayFirstCount > monthFirstCount ? "day-first" : "month-first";
+};

package/src/derived/stays.ts

@@ -1,7 +1,7 @@
 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 { ATTRIBUTIVE_REACH, 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";
@@ -11,7 +11,11 @@ import { withoutEdgeMarks } from "../facts/trim-marks.ts";
  * 一つの文に日付がちょうど二つと泊数がちょうど一つあるときと、チェックイン・チェックアウト・泊数の列がそろった表の行で比べる。
  * 「2泊3日」のように泊数と日数を並べたものは、日数が泊数より一つ多いかを見る。Pure.
  */
-export type Count = Span & { readonly amount: number };
+export type Count = Span & {
+  readonly amount: number;
+  /** 名詞の前に書いた泊数（a 2-night package）。売り物の長さのことが多く、二つの日付の間の泊数とは限らない。 */
+  readonly attributive?: boolean;
+};
 
 export type NightsMismatch = { readonly start: DatedValue; readonly end: DatedValue; readonly nights: Span; readonly expected: number };
 
@@ -52,6 +56,7 @@ const nightsBetween = (first: DatedValue, second: DatedValue): Between | undefin
 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;
+  if (nights.attributive === true && between.nights > nights.amount * ATTRIBUTIVE_REACH) return undefined;
   return { start: between.start, end: between.end, nights, expected: between.nights };
 };
 

package/src/derived/time-lengths.ts

@@ -44,8 +44,8 @@ const numberOf = (written: string, numberWords: readonly string[]): number => {
 /** 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 digits = "(?<![\\p{N}.,．/⁄])(?<digits>\\p{Nd}+(?:[.．]\\p{Nd}+)?)";
+  return words === "" ? digits : `(?:${digits}|(?<![\\p{L}\\p{N}\\p{Pd}])(?<word>${words}))`;
 };
 
 const SEPARATOR = "[\\s\\-‐]?";
@@ -71,17 +71,18 @@ const smallestUnit = (number: string | undefined, minutes: string | undefined, h
 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 minutePart = minutes === "" ? "" : `|\\s?(?<extra>\\p{Nd}{1,2})\\s?(?:${minutes})`;
+  const halfPart = halves === "" ? "" : `|\\s?(?<half>${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 { digits, word, extra, half } = match.groups ?? {};
+    const amount = numberOf(digits ?? word ?? "", words.numberWords);
+    const extraMinutes = extra === undefined ? 0 : Number(extra.normalize("NFKC"));
+    const halfMinutes = half === undefined ? 0 : HALF_HOUR;
+    return [{ span: { start: match.index, end }, minutes: amount * MINUTES_PER_HOUR + extraMinutes + halfMinutes, unit: smallestUnit(digits, extra, half) }];
   });
 };
 
@@ -91,7 +92,9 @@ const minuteLengths = (text: string, words: LengthWords): Read[] => {
   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 }];
+    return runsOn(text, end)
+      ? []
+      : [{ span: { start: match.index, end }, minutes: numberOf(match.groups?.["digits"] ?? match.groups?.["word"] ?? "", words.numberWords), unit: 1 }];
   });
 };
 

package/src/derived/timesheet-hours.ts

@@ -0,0 +1,112 @@
+import type { Span } from "../plugin.ts";
+import { linesOf } from "../structure/lines.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { columnOf, hasHeadingNote, onlyTime } from "../structure/shift-times.ts";
+import { rangeReading } from "../structure/time-range.ts";
+import type { Mark, TimeSpan } from "../structure/time-marks.ts";
+import type { ClockRange } from "./working-hours.ts";
+
+/**
+ * 勤務表の行の実働（始業 | 終業 | 休憩 | 実働、Start | End | Break | Hours）を、終わりから始まりと休憩を引いた長さと比べる。
+ * 列は見出しの名前で読む（語彙表 shift-column）。始まりと終わりの列が無ければ、一つの升に書いた範囲（9:30〜18:30）を読む。
+ * 休憩の列と実働の列が両方ある表だけを読み、どれかの升が読めない行は言わない（休憩が勤務より長い行は実働を読まずに言う）。休憩の升の単位の無い数（30）は分か時間か
+ * 分からないので読まない。片方にだけ午前・午後を書いた行も読まない。終わりが始まりより前の行は、文書に夜をまたぐ勤務の印が
+ * あるときだけ日をまたいで読み、無ければ言わない（time-range-reversed が見る）。Pure.
+ */
+
+const SECONDS_PER_MINUTE = 60;
+const MINUTES_PER_DAY = 24 * 60;
+/** 実働を小数の時間で書いたときの丸め（8.33 は 499.8 分）。 */
+const ROUNDING_MINUTES = 3;
+
+export type TimesheetInputs = {
+  readonly text: string;
+  readonly times: readonly TimeSpan[];
+  /** 一つの升に書いた時刻の範囲（9:30〜18:30）。 */
+  readonly ranges: readonly ClockRange[];
+  readonly columns: readonly Mark[];
+  readonly overnight: boolean;
+  /** 升に書いた長さを分で。bareHours なら単位の無い数（8.00）も時間と読む。 */
+  readonly lengthOf: (text: string, bareHours: boolean) => number | undefined;
+};
+
+export type TimesheetMismatch = {
+  readonly start: Span;
+  readonly end: Span;
+  readonly break: Span;
+  /** 休憩が勤務より長い行では読まない。 */
+  readonly total?: Span & { readonly minutes: number };
+  /** 終わりから始まりと休憩を引いた分。負なら休憩が勤務より長い。 */
+  readonly expected: number;
+};
+
+type Columns = { readonly start: number; readonly end: number; readonly hours: number; readonly break: number; readonly bareHours: boolean };
+
+const trimmed = (cell: Cell): Span & { readonly text: string } => {
+  const text = cell.text.trim();
+  const start = cell.start + cell.text.indexOf(text);
+  return { start, end: start + text.length, text };
+};
+
+/** 始まりと終わりの列の時刻。十二時間制の片方にだけ午前・午後を書いた組は読まない。 */
+const columnTimes = (cells: readonly Cell[], columns: Columns, inputs: TimesheetInputs) => {
+  const [from, to] = [onlyTime(cells[columns.start], inputs.times, inputs.text), onlyTime(cells[columns.end], inputs.times, inputs.text)];
+  if (from === undefined || to === undefined) return undefined;
+  const reading = rangeReading(inputs.text, from, to);
+  return reading.borrowed ? undefined : { from, to, minutes: (reading.to - reading.from) / SECONDS_PER_MINUTE };
+};
+
+/** 一つの升に範囲だけを書いた行の、その範囲。実働と休憩の列のほかに、そういう升が一つだけのときに読む。 */
+const rangeTimes = (cells: readonly Cell[], columns: Columns, inputs: TimesheetInputs) => {
+  const others = cells.filter((_cell, index) => index !== columns.hours && index !== columns.break);
+  const found = others.flatMap((cell) => {
+    const within = trimmed(cell);
+    return inputs.ranges.filter((range) => range.start === within.start && range.end === within.end);
+  });
+  const range = found.length === 1 ? found[0] : undefined;
+  if (range === undefined || rangeReading(inputs.text, range.from, range.to).borrowed) return undefined;
+  return { from: range.from, to: range.to, minutes: range.minutes ?? (range.to.seconds - range.from.seconds) / SECONDS_PER_MINUTE };
+};
+
+/** 勤務の長さ。日をまたぐ行は、夜をまたぐ勤務の印のある文書でだけ読む。 */
+const shiftMinutes = (minutes: number, overnight: boolean): number | undefined => {
+  if (minutes > 0) return minutes;
+  return overnight && minutes < 0 ? minutes + MINUTES_PER_DAY : undefined;
+};
+
+const lengthCell = (cell: Cell | undefined, inputs: TimesheetInputs, bareHours: boolean) => {
+  if (cell === undefined) return undefined;
+  const span = trimmed(cell);
+  const minutes = inputs.lengthOf(span.text, bareHours);
+  return minutes === undefined ? undefined : { ...span, minutes };
+};
+
+const rowMismatch = (cells: readonly Cell[], columns: Columns, inputs: TimesheetInputs): TimesheetMismatch | undefined => {
+  const times = columns.start === -1 ? rangeTimes(cells, columns, inputs) : columnTimes(cells, columns, inputs);
+  const shift = times === undefined ? undefined : shiftMinutes(times.minutes, inputs.overnight);
+  const breakLength = lengthCell(cells[columns.break], inputs, false);
+  const total = lengthCell(cells[columns.hours], inputs, columns.bareHours);
+  if (times === undefined || shift === undefined || breakLength === undefined) return undefined;
+  const expected = shift - breakLength.minutes;
+  if (expected < 0) return { start: times.from, end: times.to, break: breakLength, expected };
+  if (total === undefined || Math.abs(expected - total.minutes) <= ROUNDING_MINUTES) return undefined;
+  return { start: times.from, end: times.to, break: breakLength, total, expected };
+};
+
+const columnsOf = (header: readonly Cell[], marks: readonly Mark[]): Columns | undefined => {
+  const [start, end, hours, rest] = (["start", "end", "hours", "break"] as const).map((side) => columnOf(header, marks, side));
+  if (start === undefined || end === undefined || hours === undefined || rest === undefined || hours === -1 || rest === -1) return undefined;
+  if ((start === -1) !== (end === -1)) return undefined;
+  return { start, end, hours, break: rest, bareHours: !hasHeadingNote(header[hours]?.text ?? "") };
+};
+
+/** 勤務表の行で、実働が終わり − 始まり − 休憩と合わないもの、休憩が勤務より長いもの。 */
+export const timesheetHoursMismatches = (inputs: TimesheetInputs): TimesheetMismatch[] =>
+  tablesOf(linesOf(inputs.text)).flatMap((table) => {
+    const columns = columnsOf(cellsOf(table.header), inputs.columns);
+    if (columns === undefined) return [];
+    return table.rows.flatMap((line) => {
+      const mismatch = rowMismatch(cellsOf(line), columns, inputs);
+      return mismatch === undefined ? [] : [mismatch];
+    });
+  });