chaffjs 0.31.0 → 0.32.0

package/src/derived/hours-and-minutes.ts

@@ -0,0 +1,41 @@
+/**
+ * A computed length of time as whole hours and minutes, and which of the two a message writes: 4時間15分 / 4 hours 15
+ * minutes, 7時間 / 7 hours, 45分 / 45 minutes. A part of a minute is rounded to the nearest minute (half up).
+ */
+export type HoursAndMinutes = {
+  readonly hours: number;
+  readonly minutes: number;
+  /** "hours" when the minutes are 0, "minutes" under an hour (0 too), else "hours-minutes". */
+  readonly shape: "hours" | "minutes" | "hours-minutes";
+};
+
+const MINUTES_PER_HOUR = 60;
+
+/** undefined for a length that cannot be written: negative, NaN or infinite. */
+export const hoursAndMinutes = (totalMinutes: number): HoursAndMinutes | undefined => {
+  if (!Number.isFinite(totalMinutes) || totalMinutes < 0) return undefined;
+  const whole = Math.round(totalMinutes);
+  const hours = Math.floor(whole / MINUTES_PER_HOUR);
+  const minutes = whole % MINUTES_PER_HOUR;
+  if (hours === 0) return { hours, minutes, shape: "minutes" };
+  return { hours, minutes, shape: minutes === 0 ? "hours" : "hours-minutes" };
+};
+
+/** Whether a computed length would be written as the stated one: a message saying "8 hours, but 8 hours is written" says nothing. */
+export const readsTheSame = (computedMinutes: number, statedMinutes: number): boolean => Math.round(computedMinutes) === Math.round(statedMinutes);
+
+const HOUR_DECIMALS = 100;
+
+/** The computed length for a message: decimal hours as `expected` (kept for JSON readers), hours and minutes to write. */
+export type ComputedLength = {
+  readonly shape: HoursAndMinutes["shape"];
+  readonly values: { readonly expected: number; readonly hours: number; readonly minutes: number };
+};
+
+/** undefined when the computed length cannot be written, or would be written as the stated one. */
+export const computedLength = (computedMinutes: number, statedMinutes: number): ComputedLength | undefined => {
+  const length = hoursAndMinutes(computedMinutes);
+  if (length === undefined || readsTheSame(computedMinutes, statedMinutes)) return undefined;
+  const expected = Math.round((computedMinutes / MINUTES_PER_HOUR) * HOUR_DECIMALS) / HOUR_DECIMALS;
+  return { shape: length.shape, values: { expected, hours: length.hours, minutes: length.minutes } };
+};

package/src/derived/hyphenated-counts.ts

@@ -0,0 +1,38 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/** A figure joined to its unit by a hyphen ("a 3-month trial", "a 2-night, 3-day tour"), with the unit as written in the list. */
+export type HyphenatedCount = Span & { readonly amount: number; readonly unit: string; readonly attributive: true };
+
+const HYPHENS = "[-‐‑]";
+
+const alternation = (units: readonly string[]): string =>
+  units
+    .filter((unit) => unit !== "")
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+/**
+ * Figures in digits joined by a hyphen to one of the units. The unit ends the word: "3-month-old" is an age and "3-monthly"
+ * another word, and a figure inside a longer number or word ("2026-04-3-day", "v2-day") is not a count. Pure.
+ */
+export const hyphenatedCounts = (text: string, units: readonly string[]): HyphenatedCount[] => {
+  const words = alternation(units);
+  if (words === "") return [];
+  const pattern = new RegExp(`(?<![\\p{L}\\p{N}\\p{Pd}.,])(\\p{Nd}+)${HYPHENS}(${words})(?![\\p{L}\\p{N}\\p{Pd}])`, "giu");
+  return [...text.matchAll(pattern)].flatMap((match): HyphenatedCount[] => {
+    const unit = units.find((candidate) => candidate.toLowerCase() === (match[2] ?? "").toLowerCase());
+    return unit === undefined
+      ? []
+      : [{ start: match.index, end: match.index + match[0].length, amount: Number((match[1] ?? "").normalize("NFKC")), unit, attributive: true }];
+  });
+};
+
+/** The text before an attributive count without the article its noun takes ("up to a" → "up to"): a rough mark stands before it. Pure. */
+export const withoutArticle = (before: string, articles: readonly string[]): string => {
+  const trimmed = before.trimEnd();
+  const lower = trimmed.toLowerCase();
+  const article = articles.find((word) => word !== "" && (lower === word.toLowerCase() || lower.endsWith(` ${word.toLowerCase()}`)));
+  return article === undefined ? trimmed : trimmed.slice(0, trimmed.length - article.length).trimEnd();
+};

package/src/derived/marked-dates.ts

@@ -0,0 +1,61 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { withoutTrailingWeekday, type RangeWords } from "../structure/date-range.ts";
+
+/**
+ * 日付が三つ以上ある文で、始まりと終わりを語で印した二つ（「お買い上げ日が7月1日の場合、7月1日から12か月（7月31日まで）」）。
+ * 始まりの印は、日付の後ろの開きの語（から）か、前の枠の前の語（from）。終わりの印は、後ろの閉じの語（まで）か、前のつなぎの語
+ * （〜、until）や枠の間の語（to）、または期間のすぐ後ろで開いた括弧。語は語彙表（range-opener、range-closer、range-connector、
+ * range-frame）から受け取る。
+ */
+export type MarkText = { readonly source: string; readonly range: RangeWords };
+
+/** 印の語を探す、日付の前後の字数。印の語はこれより短い。 */
+const MARK_REACH = 40;
+const OPEN_BRACKETS: readonly string[] = ["（", "("];
+const CLOSE_BRACKETS: readonly string[] = ["）", ")"];
+const LATIN = /\p{Script=Latin}/u;
+
+/** 語が書いてあるか。ラテン文字の端は、隣がラテン文字でないときだけ（"from" は "therefrom" の終わりではない）。 */
+const hasWord = (text: string, word: string, where: "start" | "end" | "anywhere"): boolean => {
+  if (word === "") return false;
+  const head = LATIN.test(word.charAt(0)) ? "(?<!\\p{Script=Latin})" : "";
+  const tail = LATIN.test(word.at(-1) ?? "") ? "(?!\\p{Script=Latin})" : "";
+  const body = `${head}${escapeRegExp(word)}${tail}`;
+  const anchored = { start: `^${body}`, end: `${body}$`, anywhere: body }[where];
+  return new RegExp(anchored, "iu").test(text);
+};
+
+const before = (text: MarkText, date: Span): string =>
+  withoutTrailingWeekday(text.source.slice(Math.max(0, date.start - MARK_REACH), date.start).trimEnd(), text.range.weekdays ?? []);
+
+const after = (text: MarkText, date: Span): string => text.source.slice(date.end, date.end + MARK_REACH).trimStart();
+
+const isStart = (text: MarkText, date: Span): boolean =>
+  text.range.openers.some((word) => hasWord(after(text, date), word, "start")) ||
+  text.range.frames.some((frame) => hasWord(before(text, date), frame.lead, "end"));
+
+/** 期間のすぐ後ろの括弧が、日付だけを囲む（12か月（2027年6月30日））。日付で始まる注（(May 15, 2026 billing notice)）は終わりではない。 */
+const bracketAfterLength = (text: MarkText, date: Span, length: Span): boolean =>
+  length.end <= date.start &&
+  OPEN_BRACKETS.includes(text.source.slice(length.end, date.start).trim()) &&
+  CLOSE_BRACKETS.some((bracket) => after(text, date).startsWith(bracket));
+
+/** 文に変更の語（moved、postponed）があれば、日付を動かした文で、期間ではない。 */
+const isChange = (text: MarkText, sentence: Span): boolean =>
+  text.range.changes.some((word) => hasWord(text.source.slice(sentence.start, sentence.end), word, "anywhere"));
+
+const isEnd = (text: MarkText, date: Span, length: Span): boolean =>
+  text.range.closers.some((word) => hasWord(after(text, date), word, "start")) ||
+  [...text.range.connectors, ...text.range.frames.map((frame) => frame.joint)].some((word) => hasWord(before(text, date), word, "end")) ||
+  bracketAfterLength(text, date, length);
+
+/** 始まりの印の日付と終わりの印の日付が一つずつで、別の日付のときだけ、その組。 */
+export const markedPair = <T extends Span>(text: MarkText, sentence: Span, dates: readonly T[], length: Span): readonly [T, T] | undefined => {
+  if (isChange(text, sentence)) return undefined;
+  const starts = dates.filter((date) => isStart(text, date));
+  const ends = dates.filter((date) => isEnd(text, date, length));
+  const [start] = starts;
+  const [end] = ends;
+  return starts.length === 1 && ends.length === 1 && start !== undefined && end !== undefined && start !== end ? [start, end] : undefined;
+};

package/src/derived/money-span.ts

@@ -0,0 +1,10 @@
+import type { Span } from "../plugin.ts";
+
+/** A currency mark from the currency-notation lexicon and the side of the number it is written on. */
+export type CurrencyMark = { readonly pattern: string; readonly before: boolean };
+
+/** Whether the amount at span is money: a currency mark right before its number (¥1,000, $5) or as its unit (3,000円, 10 USD). */
+export const isMoneySpan = (text: string, span: Span, unit: string, marks: readonly CurrencyMark[]): boolean => {
+  const before = text.slice(0, span.start).trimEnd();
+  return marks.some((mark) => (mark.before ? before.endsWith(mark.pattern) : unit === mark.pattern));
+};

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 };
 };