chaffjs 0.31.0 → 0.32.0

package/src/structure/net-gross-weight.ts

@@ -0,0 +1,97 @@
+// net-over-gross: one row of a weight table (a packing list) with the net weight (the goods alone) and the gross weight
+// (with the packing), each in a column its heading words name. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { bodyRows, offsetOf, sameUnit } from "./order-quantity.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+export type WeightRole = "net" | "gross";
+export type WeightWord = { readonly pattern: string; readonly role: WeightRole };
+export type MassUnit = { readonly pattern: string; readonly factor: number };
+/** The heading words of each column, the words after a number that make it no exact weight (以上, "or more"), and the mass units. */
+export type WeightWords = { readonly columns: readonly WeightWord[]; readonly qualifiers: readonly string[]; readonly units: readonly MassUnit[] };
+export type WeightColumns = { readonly net: number; readonly gross: number };
+
+const ROLES: readonly WeightRole[] = ["net", "gross"];
+const LATIN = /[a-z]/u;
+/** Spaces and punctuation: "Net wt." beside "Gross weight", 「正味重量（kg）」 beside "総重量 (kg)" say the same besides. */
+const SPACES_AND_MARKS = /[\s\p{P}]+/gu;
+/** Converted weights are compared to this many decimal places, so 0.1 kg and 100 g are one weight. */
+const COMPARE_DECIMALS = 6;
+
+const wordsHeld = (key: string, words: readonly WeightWord[], role: WeightRole): WeightWord[] =>
+  words.filter((word) => word.role === role && holds(key, word.pattern));
+
+export const withoutWord = (key: string, word: string): string => {
+  const written = plain(word).toLowerCase();
+  if (!LATIN.test(written)) return key.replaceAll(written, "");
+  return key.replace(new RegExp(`(?<![a-z0-9])${escapeRegExp(written)}(?![a-z0-9])`, "gu"), "");
+};
+
+type Heading = { readonly role: WeightRole; readonly rest: string };
+
+/**
+ * The role a heading names, and what it says besides ("(kg)", "per carton"). A heading naming both ("Net / Gross weight")
+ * keeps the other role's word besides, so it never pairs with a heading of the other role.
+ */
+const headingOf = (heading: string, words: readonly WeightWord[]): Heading | undefined => {
+  const key = plain(heading).toLowerCase();
+  const role = ROLES.find((candidate) => wordsHeld(key, words, candidate).length > 0);
+  if (role === undefined) return undefined;
+  const rest = wordsHeld(key, words, role).reduce((left, word) => withoutWord(left, word.pattern), key);
+  return { role, rest: rest.replace(SPACES_AND_MARKS, "") };
+};
+
+/**
+ * The one net and the one gross column. A table with two of either, or whose two headings say different things besides
+ * net and gross ("Net weight per piece" beside "Gross weight per carton"), is not read.
+ */
+export const weightColumnsOf = (headings: readonly string[], words: readonly WeightWord[]): WeightColumns | undefined => {
+  const read = headings.map((heading) => headingOf(heading, words));
+  const all = (role: WeightRole): number[] => read.flatMap((found, index) => (found?.role === role ? [index] : []));
+  const [net, gross] = [all("net"), all("gross")];
+  const [netIndex, grossIndex] = [net[0], gross[0]];
+  if (net.length !== 1 || gross.length !== 1 || netIndex === undefined || grossIndex === undefined) return undefined;
+  const [netHeading, grossHeading] = [read[netIndex], read[grossIndex]];
+  if (netHeading === undefined || grossHeading === undefined || netHeading.rest !== grossHeading.rest) return undefined;
+  return { net: netIndex, gross: grossIndex };
+};
+
+type Weight = { readonly value: number; readonly unit: string; readonly cell: TableCell };
+
+/** A plain weight: a number with what is written after it (kg), no sign, bracket or word before it, and no bound after it. */
+const weightIn = (cell: TableCell | undefined, qualifiers: readonly string[]): Weight | undefined => {
+  const value = cell === undefined ? undefined : valueIn(cell.text);
+  if (cell === undefined || value === undefined) return undefined;
+  const [before = "", after = ""] = value.marks.split("|");
+  const unit = after.toLowerCase();
+  if (before !== "" || qualifiers.some((word) => holds(unit, word))) return undefined;
+  return { value: value.value, unit, cell };
+};
+
+const factorOf = (unit: string, units: readonly MassUnit[]): number | undefined => units.find((known) => known.pattern.toLowerCase() === unit)?.factor;
+
+const rounded = (value: number): number => Number(value.toFixed(COMPARE_DECIMALS));
+
+/** Net larger than gross: in one unit as written, or both converted by the mass units (g, kg, t). Undefined when they cannot be compared. */
+const netExceeds = (net: Weight, gross: Weight, units: readonly MassUnit[]): boolean | undefined => {
+  if (sameUnit(net.unit, gross.unit)) return net.value > gross.value;
+  const [netFactor, grossFactor] = [factorOf(net.unit, units), factorOf(gross.unit, units)];
+  if (netFactor === undefined || grossFactor === undefined) return undefined;
+  return rounded(net.value * netFactor) > rounded(gross.value * grossFactor);
+};
+
+/** Each row (the totals row too) whose net weight is larger than its gross weight. */
+export const netOverGross = (tables: readonly ChangeTable[], words: WeightWords): StructureIssue[] =>
+  tables.flatMap((table) => {
+    const columns = weightColumnsOf(
+      table.header.map((cell) => cell.text),
+      words.columns,
+    );
+    if (columns === undefined) return [];
+    return bodyRows(table).flatMap((row) => {
+      const [net, gross] = [weightIn(row[columns.net], words.qualifiers), weightIn(row[columns.gross], words.qualifiers)];
+      if (net === undefined || gross === undefined || netExceeds(net, gross, words.units) !== true) return [];
+      return [{ offset: offsetOf(net.cell), values: { net: plain(net.cell.text), gross: plain(gross.cell.text) } }];
+    });
+  });

package/src/structure/order-quantity.ts

@@ -0,0 +1,125 @@
+// delivered-over-ordered and backorder-mismatch: one row of a quantity table (a delivery note, a backorder list) with the
+// ordered, delivered and backordered quantities, each in a column its heading words name. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+
+export type QuantityRole = "ordered" | "delivered" | "backordered";
+export type QuantityWord = { readonly pattern: string; readonly role: QuantityRole };
+export type QuantityColumns = { readonly ordered: number; readonly delivered: number; readonly backordered?: number };
+/** The heading words of each column, and the words after a number that make it no exact count (以上, "or more"). */
+export type QuantityWords = { readonly columns: readonly QuantityWord[]; readonly qualifiers: readonly string[] };
+
+/** Backordered first: 「発注残」 holds 発注 and 「未納品数」 holds 納品数, "Back ordered" holds "ordered", and both are what is left. */
+const ROLE_ORDER: readonly QuantityRole[] = ["backordered", "delivered", "ordered"];
+
+/** A heading that names both ordered and delivered ("Ordered / Delivered") says neither: it is no column to read. */
+const BOTH = "both";
+
+export const roleOf = (heading: string, words: readonly QuantityWord[]): QuantityRole | typeof BOTH | undefined => {
+  const key = plain(heading).toLowerCase();
+  const named = ROLE_ORDER.filter((role) => words.some((word) => word.role === role && holds(key, word.pattern)));
+  if (!named.includes("backordered") && named.includes("delivered") && named.includes("ordered")) return BOTH;
+  return named[0];
+};
+
+/**
+ * The one ordered and the one delivered column, and the one backordered column when there is one. Two delivered columns
+ * (前回 and 今回, "Previously" and "Now") say neither alone what is left, so a table with two is not read.
+ */
+export const quantityColumnsOf = (headings: readonly string[], words: readonly QuantityWord[]): QuantityColumns | undefined => {
+  const roles = headings.map((heading) => roleOf(heading, words));
+  const all = (role: QuantityRole): number[] => roles.flatMap((found, index) => (found === role ? [index] : []));
+  const [ordered, delivered, backordered] = [all("ordered"), all("delivered"), all("backordered")];
+  if (roles.includes(BOTH) || ordered.length !== 1 || delivered.length !== 1 || backordered.length > 1) return undefined;
+  const [orderedIndex = 0, deliveredIndex = 0] = [ordered[0], delivered[0]];
+  return { ordered: orderedIndex, delivered: deliveredIndex, ...(backordered[0] === undefined ? {} : { backordered: backordered[0] }) };
+};
+
+type Count = { readonly value: number; readonly unit: string; readonly cell: TableCell };
+
+/**
+ * A plain count: a whole number with what is written after it (冊, boxes), no sign, bracket, decimals or mark before it,
+ * and no word after it that makes it a bound or a guess (10以上, "12 or more").
+ */
+const countIn = (cell: TableCell | undefined, qualifiers: readonly string[]): Count | undefined => {
+  const value = cell === undefined ? undefined : valueIn(cell.text);
+  if (cell === undefined || value === undefined || value.step !== 1) return undefined;
+  const [before = "", after = ""] = value.marks.split("|");
+  const unit = after.toLowerCase();
+  if (before !== "" || qualifiers.some((word) => holds(unit, word))) return undefined;
+  return { value: value.value, unit, cell };
+};
+
+/** The plural forms of an English unit: "reams", "boxes", "copies". */
+const pluralsOf = (unit: string): string[] => [
+  `${unit}s`,
+  ...(/(?:s|x|z|ch|sh|o)$/u.test(unit) ? [`${unit}es`] : []),
+  ...(/[^aeiou]y$/u.test(unit) ? [`${unit.slice(0, -1)}ies`] : []),
+];
+
+/** One unit, written singular or plural: "box" and "boxes", "copy" and "copies". */
+export const sameUnit = (left: string, right: string): boolean => left === right || pluralsOf(left).includes(right) || pluralsOf(right).includes(left);
+
+export const offsetOf = (cell: TableCell): number => cell.start + (cell.text.length - cell.text.trimStart().length);
+
+/** The counts of a row's columns, when every one is a count in one unit; undefined when any cell says something else. */
+const countsOf = (row: readonly TableCell[], indexes: readonly number[], qualifiers: readonly string[]): Count[] | undefined => {
+  const counts = indexes.map((index) => countIn(row[index], qualifiers));
+  const read = counts.flatMap((count) => (count === undefined ? [] : [count]));
+  const [first] = read;
+  if (read.length !== indexes.length || first === undefined || !read.every((count) => sameUnit(count.unit, first.unit))) return undefined;
+  return read;
+};
+
+export const bodyRows = (table: ChangeTable): (readonly TableCell[])[] => table.rows.filter((row) => row.length === table.header.length);
+
+const columnsOfTable = (table: ChangeTable, words: QuantityWords): QuantityColumns | undefined =>
+  quantityColumnsOf(
+    table.header.map((cell) => cell.text),
+    words.columns,
+  );
+
+/** Each row whose delivered quantity is larger than its ordered quantity. */
+export const deliveredOverOrdered = (tables: readonly ChangeTable[], words: QuantityWords): StructureIssue[] =>
+  tables.flatMap((table) => {
+    const columns = columnsOfTable(table, words);
+    if (columns === undefined) return [];
+    return bodyRows(table).flatMap((row) => {
+      const [ordered, delivered] = countsOf(row, [columns.ordered, columns.delivered], words.qualifiers) ?? [];
+      if (ordered === undefined || delivered === undefined || delivered.value <= ordered.value) return [];
+      return [{ offset: offsetOf(delivered.cell), values: { delivered: plain(delivered.cell.text), ordered: plain(ordered.cell.text) } }];
+    });
+  });
+
+/** The expected count written the way the backordered cell writes its own: thousands commas and the unit after it. */
+const shownCount = (value: number, written: Count): string => {
+  const text = plain(written.cell.text);
+  return text.replace(/^[\d,]+/u, value.toLocaleString("en-US", { useGrouping: text.includes(",") }));
+};
+
+/** Another column of the row holds a count in the same unit (opening stock, previously delivered): the remainder may count it too. */
+const countsElsewhere = (row: readonly TableCell[], used: readonly number[], unit: string, qualifiers: readonly string[]): boolean =>
+  row.some((cell, index) => {
+    const count = used.includes(index) ? undefined : countIn(cell, qualifiers);
+    return count !== undefined && sameUnit(count.unit, unit);
+  });
+
+/**
+ * Each row whose backordered quantity is not the ordered less the delivered. A row that delivered more than was ordered is
+ * left to delivered-over-ordered: what is left of it is no count.
+ */
+export const backorderMismatches = (tables: readonly ChangeTable[], words: QuantityWords): StructureIssue[] =>
+  tables.flatMap((table) => {
+    const columns = columnsOfTable(table, words);
+    if (columns?.backordered === undefined) return [];
+    const backorderedColumn = columns.backordered;
+    return bodyRows(table).flatMap((row) => {
+      const used = [columns.ordered, columns.delivered, backorderedColumn];
+      const [ordered, delivered, backordered] = countsOf(row, used, words.qualifiers) ?? [];
+      if (ordered === undefined || delivered === undefined || backordered === undefined || delivered.value > ordered.value) return [];
+      if (countsElsewhere(row, used, ordered.unit, words.qualifiers)) return [];
+      const expected = ordered.value - delivered.value;
+      if (backordered.value === expected) return [];
+      return [{ offset: offsetOf(backordered.cell), values: { backordered: plain(backordered.cell.text), computed: shownCount(expected, backordered) } }];
+    });
+  });

package/src/structure/party-role.ts

@@ -1,4 +1,5 @@
 import type { BodyText, DefinedTerm } from "./definition-use.ts";
+import { isGenericPlural } from "./generic-role.ts";
 
 /**
  * 当事者を、定めた呼び名でなく立場の語で書いた所（「乙」と定めたあとの「受託者」、the "Supplier" のあとの the Vendor）。
@@ -64,7 +65,9 @@ const CLAUSE_START = /^[\s\d.()*+-]*$/u;
 /** 英語の立場の語は、冠詞か所有の語のあと（the Vendor）か、文の頭の大文字の語だけ。小文字の the vendor は普通の名詞。 */
 const englishRoleAt = (text: BodyText, at: number, role: string): boolean => {
   const before = text.text.slice(0, at);
-  return ENGLISH_ENDING.test(text.text.slice(at + role.length)) && (CLAUSE_START.test(before) || ENGLISH_LEAD.test(before.slice(-LEAD_REACH)));
+  const after = text.text.slice(at + role.length);
+  const bare = CLAUSE_START.test(before);
+  return ENGLISH_ENDING.test(after) && !isGenericPlural(bare, after) && (bare || ENGLISH_LEAD.test(before.slice(-LEAD_REACH)));
 };
 
 const standsAlone = (source: string, text: BodyText, at: number, role: string): boolean => {

package/src/structure/percent-sum.ts

@@ -16,6 +16,8 @@ export type ShareWords = {
   readonly columnLabels?: readonly string[];
   /** 行ごとの率を名指す語（前年比、達成率、growth）。表の上の文にあれば、columnLabels の列は足さない。 */
   readonly rates?: readonly string[];
+  /** 列の見出しの升にだけ効く、行ごとの率の語（還元率、Discount）。見出しでは rates の語も同じに読む。 */
+  readonly headerRates?: readonly string[];
   /** 足しても 100% にならない集計（複数回答）。 */
   readonly exceptions: readonly string[];
   /** 全体の残りを名指す語（その他、other）。一つの文の百分率のすぐ前にあれば、その文は内訳。 */
@@ -112,6 +114,7 @@ type Named = { readonly header: readonly string[]; readonly above: string; reado
 const namesShares = (named: Named, column: number, percentColumns: number, words: ShareWords): boolean => {
   const header = named.header[column] ?? "";
   if (named.header.length > 0 && includesAny(header, words.labels)) return true;
+  if (mentionsAny(header, [...(words.rates ?? []), ...(words.headerRates ?? [])])) return false;
   if (isShareColumn(header, words.columnLabels ?? []) && !mentionsAny(`${named.above} ${named.rows}`, words.rates ?? [])) return true;
   return (named.header.length === 0 || percentColumns === 1) && includesAny(named.above, words.labels);
 };

package/src/structure/period-label-conflict.ts

@@ -0,0 +1,174 @@
+import { escapeRegExp } from "../orthography.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { periodLabelsIn, type CompiledFrame, type PeriodLabel } from "./period-labels.ts";
+import { afterLabel } from "./stated-period.ts";
+
+// 決算の文書が題で言った期間（2027年3月期 第2四半期、Q2 FY2026）と、今の業績を言う所に書いた同じ種類の別の期間（第3四半期、FY2025）。
+// 純関数: 文書の字、文と見出しの範囲、語彙表の語を受け取る。
+// 文書の期間は、題（最初の字のある行）が業績の語（決算、業績、Financial Results）と一緒に書いた期間の名前。
+// 題に無い種類は、頭の「対象期間：」「Reporting period:」の一行から補う。題に同じ種類の違う期間が二つあれば、その種類は比べない。
+// 書き方そのものが文書の年を言う名前（令和8年分、Tax Year 2026）は、業績の語が無い題からも読み、本文のどの文の中でも比べる。
+
+export type ReportingWords = {
+  readonly frames: readonly CompiledFrame[];
+  /** 業績を言う語。題がこれを持つ文書だけを読み、文がこれを持てば今の業績を言う文と読む。 */
+  readonly results: readonly string[];
+  /** 文書の期間を書く行の頭の語（対象期間、Reporting period）。 */
+  readonly periodLines: readonly string[];
+  /** 比べる相手の期間を言う語（前年同期、prior year）。 */
+  readonly comparisons: readonly string[];
+  /** 先の期間の見込みを言う語（通期予想、outlook）。 */
+  readonly forecasts: readonly string[];
+  /** 今の期間を指す語（当期、当第、this quarter）。 */
+  readonly currents: readonly string[];
+  /** 今の期間の語を含むが期間を指さない語（当期純利益）。 */
+  readonly notCurrents: readonly string[];
+  /** 期間の名前の書き方を含むが名前ではない語（分担金の「年分担」）。 */
+  readonly notNames: readonly string[];
+};
+
+export type Span = { readonly start: number; readonly end: number };
+export type Heading = Span & { readonly text: string };
+
+export type PeriodConflict = { readonly offset: number; readonly label: string; readonly stated: string };
+
+type Unit = {
+  readonly start: number;
+  readonly text: string;
+  readonly headerCell: boolean;
+  /** 文書の期間の名前を探す範囲。表の見出しの升なら行全体（| FY2025 | FY2026 | の FY2025 は比べる相手）。 */
+  readonly context: string;
+  readonly section: string;
+};
+
+const HEAD_LINES = 12;
+const ASCII_EDGE = /[A-Za-z0-9]/u;
+
+const wordRegex = (word: string): RegExp => {
+  const before = ASCII_EDGE.test(word.charAt(0)) ? "(?<![A-Za-z0-9])" : "";
+  const after = ASCII_EDGE.test(word.charAt(word.length - 1)) ? "(?![A-Za-z0-9])" : "";
+  return new RegExp(`${before}${escapeRegExp(word).replaceAll(" ", "\\s+")}${after}`, "iu");
+};
+
+export const hasWord = (text: string, words: readonly string[]): boolean => words.some((word) => word !== "" && wordRegex(word).test(text));
+
+const withoutWords = (text: string, words: readonly string[]): string =>
+  words.filter((word) => word !== "").reduce((rest, word) => rest.replace(new RegExp(wordRegex(word).source, "giu"), " "), text);
+
+const occurrencesOf = (text: string, word: string): Span[] =>
+  word === "" ? [] : [...text.matchAll(new RegExp(escapeRegExp(word), "gu"))].map((match) => ({ start: match.index, end: match.index + word.length }));
+
+/** 名前の終わりが、名前ではない語の途中に落ちるか（令和8年分担金の「令和8年分」）。 */
+const endsInsideNotName = (text: string, label: PeriodLabel, notNames: readonly string[]): boolean =>
+  notNames.some((word) => occurrencesOf(text, word).some((span) => span.start < label.end && label.end < span.end));
+
+const labelsIn = (text: string, words: ReportingWords): PeriodLabel[] =>
+  periodLabelsIn(text, words.frames).filter((label) => !endsInsideNotName(text, label, words.notNames));
+
+const sameLabel = (left: PeriodLabel, right: PeriodLabel): boolean => left.kind === right.kind && left.shape === right.shape && left.value === right.value;
+const sameSlot = (left: PeriodLabel, right: PeriodLabel): boolean => left.kind === right.kind && left.shape === right.shape;
+
+/** 種類と形ごとに一つの期間。同じ種類と形の違う期間が並べば、どちらが文書の期間か決まらないので落とす。 */
+const oneEach = (labels: readonly PeriodLabel[]): PeriodLabel[] =>
+  labels.filter(
+    (label, index) =>
+      labels.every((other) => !sameSlot(other, label) || sameLabel(other, label)) && labels.findIndex((other) => sameLabel(other, label)) === index,
+  );
+
+/** 文書の期間。題が業績の語を持たなければ、書き方そのものが年を言う名前だけ。題に無い種類と形だけを、期間の行から補う。 */
+export const statedPeriodOf = (title: string, periodLine: string, words: ReportingWords): PeriodLabel[] => {
+  const results = hasWord(title, words.results);
+  const readable = (text: string): PeriodLabel[] => oneEach(labelsIn(text, words).filter((label) => results || label.titleAlone));
+  const fromTitle = readable(title);
+  if (fromTitle.length === 0 && !results) return [];
+  const fromLine = readable(periodLine).filter((label) => !fromTitle.some((other) => sameSlot(other, label)));
+  return [...fromTitle, ...fromLine];
+};
+
+/** 名前と同じ種類と形で、値の違う文書の期間。 */
+export const conflictingStated = (label: PeriodLabel, stated: readonly PeriodLabel[]): PeriodLabel | undefined => {
+  const slot = stated.find((other) => sameSlot(other, label));
+  return slot === undefined || sameLabel(slot, label) ? undefined : slot;
+};
+
+/**
+ * 今の業績を言う所の名前か。書き方そのものが年を言う名前（2025年分）は、どこに書いても文書の年を言う。年の中の一部（四半期、半期）で文書の期間より前のものは、累計の中の一部や比べる相手のことが多いので、
+ * 今の期間を指す語（当第1四半期）があるときだけ。ほかは、表の見出しの升ならそれだけで、文なら今の期間か業績の語があるとき。
+ */
+export const refersToCurrent = (label: PeriodLabel, stated: PeriodLabel, unit: Pick<Unit, "text" | "headerCell">, words: ReportingWords): boolean => {
+  const current = hasWord(withoutWords(unit.text, words.notCurrents), words.currents);
+  if (label.withinYear && label.order < stated.order) return current;
+  return label.titleAlone || unit.headerCell || current || hasWord(unit.text, words.results);
+};
+
+const isAside = (text: string, words: ReportingWords): boolean => hasWord(text, words.comparisons) || hasWord(text, words.forecasts);
+
+const issuesIn = (unit: Unit, stated: readonly PeriodLabel[], words: ReportingWords): PeriodConflict[] => {
+  if (isAside(unit.text, words) || isAside(unit.section, words)) return [];
+  const named = labelsIn(unit.context, words);
+  return labelsIn(unit.text, words).flatMap((label) => {
+    const statedLabel = conflictingStated(label, stated);
+    if (statedLabel === undefined || named.some((other) => sameLabel(other, statedLabel))) return [];
+    if (!refersToCurrent(label, statedLabel, unit, words)) return [];
+    return [{ offset: unit.start + label.start, label: label.written, stated: statedLabel.written }];
+  });
+};
+
+const RULE_CELL = /^:?-{3,}:?$/u;
+
+/** 表の見出しと本体を分ける行（| --- | :---: |）。 */
+const isTableRule = (text: string): boolean => {
+  const cells = text.trim().replace(/^\|/u, "").replace(/\|$/u, "").split("|");
+  return text.includes("-") && cells.every((cell) => RULE_CELL.test(cell.trim()));
+};
+
+const cellsOf = (line: Line): { readonly start: number; readonly text: string }[] => {
+  const cells: { start: number; text: string }[] = [];
+  let at = line.start;
+  line.text.split("|").forEach((text) => {
+    cells.push({ start: at, text });
+    at += text.length + 1;
+  });
+  return cells.filter((cell) => cell.text.trim() !== "");
+};
+
+/** 表の見出しの行（次の行が |---| の行）の升。 */
+const headerRows = (lines: readonly Line[]): Line[] =>
+  lines.filter((line, index) => line.text.trimStart().startsWith("|") && isTableRule(lines[index + 1]?.text ?? ""));
+
+const sectionAt = (headings: readonly Heading[], offset: number): string => headings.findLast((heading) => heading.start < offset)?.text ?? "";
+
+const headerUnits = (lines: readonly Line[], headings: readonly Heading[]): Unit[] =>
+  headerRows(lines).flatMap((row) =>
+    cellsOf(row).map((cell) => ({ start: cell.start, text: cell.text, headerCell: true, context: row.text, section: sectionAt(headings, cell.start) })),
+  );
+
+const textUnits = (source: string, spans: readonly Span[], headings: readonly Heading[]): Unit[] =>
+  spans.map((span) => {
+    const text = source.slice(span.start, span.end);
+    return { start: span.start, text, headerCell: false, context: text, section: sectionAt(headings, span.start) };
+  });
+
+type Head = { readonly title: string; readonly periodLine: string; readonly end: number };
+
+/** 題（最初の字のある行）と、その後ろ、次の見出しまでの頭の行のうち期間の語で始まる一行。 */
+const headOf = (lines: readonly Line[], headings: readonly Heading[], words: ReportingWords): Head => {
+  const first = lines.find((line) => line.text.trim() !== "");
+  const titleEnd = first === undefined ? 0 : first.start + first.text.length;
+  const bodyStart = headings.find((heading) => heading.start > titleEnd)?.start ?? Number.POSITIVE_INFINITY;
+  const head = lines.filter((line) => line.start > titleEnd && line.start < bodyStart).slice(0, HEAD_LINES);
+  const periodLine = head.find((line) => afterLabel(line.text, words.periodLines) !== undefined);
+  const end = periodLine === undefined ? titleEnd : periodLine.start + periodLine.text.length;
+  return { title: first?.text.replace(/^#+\s*/u, "") ?? "", periodLine: periodLine?.text ?? "", end };
+};
+
+/** 題の期間と同じ種類の別の期間を、今の業績を言う文、見出し、表の見出しの升に書いた所。 */
+export const periodLabelConflicts = (source: string, sentences: readonly Span[], headings: readonly Heading[], words: ReportingWords): PeriodConflict[] => {
+  const lines = linesOf(source);
+  const head = headOf(lines, headings, words);
+  const stated = statedPeriodOf(head.title, head.periodLine, words);
+  if (stated.length === 0) return [];
+  const sections = headings.filter((heading) => heading.start > head.end);
+  const units = [...textUnits(source, [...sentences, ...sections], sections), ...headerUnits(lines, sections)].filter((unit) => unit.start > head.end);
+  return units.flatMap((unit) => issuesIn(unit, stated, words)).toSorted((left, right) => left.offset - right.offset);
+};

package/src/structure/period-labels.ts

@@ -0,0 +1,147 @@
+import { escapeRegExp } from "../orthography.ts";
+
+// 期間の名前（第2四半期、Q2、FY2026、2026年3月期、上期）を読む。純関数: 書き方は語彙表から受け取る。
+// 書き方の {n} は四半期や半期の番号、{y} は年、{e} は期間の終わる年、{m} は月、{_} は値に入らない短い語（Fiscal Year Ending {_} {e} の日付）。
+// FY2026 が 2026 年に始まる年か終わる年かは会社で違うので、{y} の名前と {e} の名前は比べない。
+// 番号を書かない書き方（Second Quarter、上期）は、同じ期間の番号付きの書き方を instead_of に持つ。
+// {y} は元号の年（令和8）でもよく、元年の西暦の年から西暦の年にする（令和8年分と2026年分は同じ年）。
+
+export type PeriodFrame = {
+  readonly pattern: string;
+  readonly kind: string;
+  readonly insteadOf?: string | undefined;
+  /** 題に業績の語が無くても読む書き方（令和8年分、Tax Year 2026）。書き方そのものが文書の年を言う。 */
+  readonly titleAlone?: boolean | undefined;
+};
+
+/** 元号と、その元年の西暦の年（令和は 2019）。 */
+export type Era = { readonly name: string; readonly firstYear: number };
+
+/** 文の中の期間の名前一つ。shape は値に使った部分（y,m なら年と月）で、同じ shape どうしだけを比べる。order は前後を比べる数。 */
+export type PeriodLabel = {
+  readonly start: number;
+  readonly end: number;
+  readonly written: string;
+  readonly kind: string;
+  readonly shape: string;
+  readonly value: string;
+  readonly order: number;
+  /** 年を持たない名前（四半期、半期）。一年の中の一部を言う。 */
+  readonly withinYear: boolean;
+  readonly titleAlone: boolean;
+};
+
+export type CompiledFrame = {
+  readonly regex: RegExp;
+  readonly kind: string;
+  readonly insteadOf: string | undefined;
+  readonly titleAlone: boolean;
+  readonly firstYears: ReadonlyMap<string, number>;
+};
+
+const PLACEHOLDER = /\{([nyem_])\}/gu;
+const SLOT: Readonly<Record<string, string>> = {
+  n: "(?<n>[1-4１-４])",
+  y: "(?<y>[0-9０-９]{4})",
+  e: "(?<e>[0-9０-９]{4})",
+  m: "(?<m>[0-9０-９]{1,2})",
+  _: "[^\\n|。.!?]{1,24}?",
+};
+const ERA_GAP = "[ \\t\\u3000]?";
+const eraYearSlot = (eras: readonly Era[]): string =>
+  eras.length === 0 ? "" : `|(?<era>${eras.map((era) => escapeRegExp(era.name)).join("|")})${ERA_GAP}(?<eraYear>[0-9０-９]{1,2}|元)${ERA_GAP}`;
+
+const slotsFor = (eras: readonly Era[]): Readonly<Record<string, string>> => ({
+  ...SLOT,
+  y: `(?:(?<y>[0-9０-９]{4})${eraYearSlot(eras)})`,
+});
+
+const BEFORE = "(?<![A-Za-z0-9０-９])";
+const AFTER = "(?![A-Za-z0-9０-９])";
+
+const literal = (text: string): string => escapeRegExp(text).replaceAll(" ", "[ \\t\\u00a0]+");
+
+const bodyOf = (pattern: string, slots: Readonly<Record<string, string>>): string =>
+  pattern
+    .split(PLACEHOLDER)
+    .map((piece, index) => (index % 2 === 1 ? (slots[piece] ?? "") : literal(piece)))
+    .join("");
+
+const startsAlnum = (pattern: string): boolean => /^(?:[A-Za-z0-9]|\{[nyem]\})/u.test(pattern);
+const endsAlnum = (pattern: string): boolean => /(?:[A-Za-z0-9]|\{[nyem]\})$/u.test(pattern);
+
+const compile = (frame: PeriodFrame, eras: readonly Era[]): CompiledFrame => ({
+  regex: new RegExp(`${startsAlnum(frame.pattern) ? BEFORE : ""}${bodyOf(frame.pattern, slotsFor(eras))}${endsAlnum(frame.pattern) ? AFTER : ""}`, "giu"),
+  kind: frame.kind,
+  insteadOf: frame.insteadOf,
+  titleAlone: frame.titleAlone === true,
+  firstYears: new Map(eras.map((era) => [era.name, era.firstYear])),
+});
+
+export const compileFrames = (frames: readonly PeriodFrame[], eras: readonly Era[] = []): readonly CompiledFrame[] =>
+  frames.filter((frame) => frame.pattern !== "").map((frame) => compile(frame, eras));
+
+const halfWidth = (digits: string): string => digits.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0));
+
+const KEY_ORDER = ["y", "e", "m", "n"] as const;
+
+type Parts = Readonly<Partial<Record<(typeof KEY_ORDER)[number], number>>>;
+
+type Groups = Readonly<Record<string, string | undefined>> | undefined;
+
+/** 元号の年（令和8）を西暦の年（2026）にする。元年は 1。 */
+const eraYearOf = (groups: Groups, firstYears: ReadonlyMap<string, number>): Parts => {
+  const firstYear = firstYears.get(groups?.["era"] ?? "");
+  const written = groups?.["eraYear"];
+  if (firstYear === undefined || written === undefined) return {};
+  return { y: firstYear + (written === "元" ? 1 : Number(halfWidth(written))) - 1 };
+};
+
+const partsOf = (groups: Groups, firstYears: ReadonlyMap<string, number> = new Map()): Parts => ({
+  ...Object.fromEntries(KEY_ORDER.flatMap((key) => (groups?.[key] === undefined ? [] : [[key, Number(halfWidth(groups[key]))]]))),
+  ...eraYearOf(groups, firstYears),
+});
+
+/** 番号を書かない書き方の値は、instead_of に書いた番号付きの書き方から読む。 */
+const insteadParts = (insteadOf: string, frames: readonly CompiledFrame[], kind: string): Parts | undefined => {
+  const frame = frames.find(
+    (candidate) => candidate.kind === kind && candidate.insteadOf === undefined && new RegExp(`^(?:${candidate.regex.source})$`, "iu").test(insteadOf),
+  );
+  if (frame === undefined) return undefined;
+  return partsOf(new RegExp(`^(?:${frame.regex.source})$`, "iu").exec(insteadOf)?.groups, frame.firstYears);
+};
+
+const labelOf = (match: RegExpExecArray, parts: Parts, frame: CompiledFrame): PeriodLabel | undefined => {
+  const keys = KEY_ORDER.filter((key) => parts[key] !== undefined);
+  if (keys.length === 0) return undefined;
+  return {
+    start: match.index,
+    end: match.index + match[0].length,
+    written: match[0],
+    kind: frame.kind,
+    shape: keys.join(","),
+    value: keys.map((key) => `${key}${String(parts[key])}`).join(","),
+    order: keys.reduce((sum, key) => sum * 100 + (parts[key] ?? 0), 0),
+    withinYear: parts.y === undefined && parts.e === undefined,
+    titleAlone: frame.titleAlone,
+  };
+};
+
+const matchesOf = (text: string, frame: CompiledFrame, frames: readonly CompiledFrame[]): PeriodLabel[] =>
+  [...text.matchAll(frame.regex)].flatMap((match) => {
+    const parts = frame.insteadOf === undefined ? partsOf(match.groups, frame.firstYears) : insteadParts(frame.insteadOf, frames, frame.kind);
+    const label = parts === undefined ? undefined : labelOf(match, parts, frame);
+    return label === undefined ? [] : [label];
+  });
+
+const overlaps = (left: PeriodLabel, right: PeriodLabel): boolean => left.start < right.end && right.start < left.end;
+
+/** 文の中の期間の名前。同じ種類の名前が重なれば長いほう（Fiscal Year Ending … 2027 の中の Year Ending … 2027 は一つ）。 */
+export const periodLabelsIn = (text: string, frames: readonly CompiledFrame[]): PeriodLabel[] => {
+  const all = frames.flatMap((frame) => matchesOf(text, frame, frames)).toSorted((left, right) => right.written.length - left.written.length);
+  const kept: PeriodLabel[] = [];
+  all.forEach((label) => {
+    if (!kept.some((other) => other.kind === label.kind && overlaps(other, label))) kept.push(label);
+  });
+  return kept.toSorted((left, right) => left.start - right.start);
+};