chaffjs 0.33.0 → 0.35.0

package/src/structure/total-line.ts

@@ -1,4 +1,4 @@
-import { isTotalLabel, leadingText } from "./total.ts";
+import { isTotalLabel, leadingText, withoutLeadingBlankCells } from "./total.ts";
 import { CELL_SEPARATOR } from "./bare-numbers.ts";
 import { outsideBrackets } from "./connection-times.ts";
 
@@ -45,7 +45,13 @@ const labelText = (lead: string): string => {
 };
 
 /** 行頭の見出しを語に分ける。括弧の注記（(incl. tax)）と強調の印は除く。 */
-const labelWords = (text: string): string[] => wordsOf(outsideBrackets(labelText(leadingText(text))).replace(EMPHASIS, ""));
+const leadingLabelWords = (text: string): string[] => wordsOf(outsideBrackets(labelText(leadingText(text))).replace(EMPHASIS, ""));
+
+/** 行の見出しの語。表の行は、前の升がどれも空なら、最初の空でない升の見出しを読む。 */
+const labelWords = (text: string): string[] => leadingLabelWords(withoutLeadingBlankCells(text));
+
+/** 見出しの語で始まる行か。表の行は、前の升がどれも空なら、最初の空でない升に書いた見出しも読む（| | 合計 | 12,000円 |）。 */
+const startsWithLabel = (text: string, labels: readonly string[]): boolean => isTotalLabel(withoutLeadingBlankCells(text), labels);
 
 const startsAt = (words: readonly string[], label: readonly string[], index: number): boolean => label.every((word, offset) => words[index + offset] === word);
 
@@ -153,8 +159,8 @@ const isUnsummed = (nouns: readonly string[], unsummedNouns: readonly string[]):
  */
 const isNamedTotal = (text: string, words: TotalLineWords, header: string): boolean => {
   const label = labelWords(text).join(" ");
-  const firstColumn = labelWords(header);
-  const columns = summedColumnHeaders(text, header).map(labelWords);
+  const firstColumn = leadingLabelWords(header);
+  const columns = summedColumnHeaders(text, header).map(leadingLabelWords);
   const namesTotal = (nouns: readonly string[]): boolean =>
     !isUnsummed(nouns, words.unsummedNouns ?? []) &&
     (namesEachOther(nouns, firstColumn) || (columns.length > 0 && columns.every((headerWords) => namesEachOther(nouns, headerWords))));
@@ -163,7 +169,7 @@ const isNamedTotal = (text: string, words: TotalLineWords, header: string): bool
 
 /** 合計の語だけか、合計の語に添える語だけを前後に置いた見出しか。 */
 const isPlainTotal = (text: string, words: TotalLineWords): boolean => {
-  if (isTotalLabel(text, words.labels)) return true;
+  if (startsWithLabel(text, words.labels)) return true;
   if (words.qualifiers.length === 0) return false;
   const label = labelWords(text);
   return words.labels.some((total) => isQualifiedLabel(label, wordsOf(total), words.qualifiers));
@@ -189,7 +195,7 @@ export const withoutPeriod = (label: string, qualifier: TotalQualifier): string
  * 前の年の合計（前年合計、Prior-year total）は、期間の語が頭にも尻にも無いので読まない。
  */
 export const isPeriodTotalLine = (text: string, words: TotalLineWords): boolean => {
-  if (isTotalLabel(text, words.periodLabels ?? [])) return true;
+  if (startsWithLabel(text, words.periodLabels ?? [])) return true;
   const label = labelWords(text).join(" ");
   return (words.periodQualifiers ?? []).some((qualifier) => {
     const rest = withoutPeriod(label, qualifier);

package/src/structure/total.ts

@@ -53,15 +53,54 @@ export const leadingText = (text: string): string =>
     .replace(/^[*_]+/u, "")
     .trimStart();
 
+/** 表の行の頭に並ぶ空の升（| | 合計 |）。最初の区切りは残す。 */
+const LEADING_BLANK_CELLS = /^([ \t]*\|)(?:[ \t]*\|)+/u;
+
+/** 表の行から頭の空の升を除いたもの。合計の語を最初の空でない升に書いた行を、最初の升に書いた行と同じに読むため。 */
+export const withoutLeadingBlankCells = (row: string): string => row.replace(LEADING_BLANK_CELLS, "$1");
+
 /**
- * 合計の語のすぐ後ろ。行や列の終わり、区切り（: |）、括弧の注記（合計（税込））、金額。
+ * 合計の語のすぐ後ろ。行や列の終わり、区切り（: |）、金額。括弧の注記は endsLabel が飛ばす。
  * 「計画」や「Total conversion: 25%」のように語が続くものは合計の行ではない。
  */
-const AFTER_LABEL = /^[*_]*[ \t\u3000]*(?:$|[:：|（(]|[-−▲△$€£¥￥\p{N}])/u;
+const AFTER_LABEL = /^[*_]*[ \t\u3000]*(?:$|[:：|]|[-−▲△$€£¥￥\p{N}])/u;
+
+/** 見出しのすぐ後ろの括弧の注記（合計（税込）、Total (incl. tax)）の開き。 */
+const NOTE_OPEN = /^[*_]*[ \t\u3000]*[（(]/u;
+const OPENERS = new Set(["(", "（"]);
+const CLOSERS = new Set([")", "）"]);
+
+type NoteScan = { readonly depth: number; readonly end: number | undefined; readonly stopped: boolean };
+
+/** 開きの括弧（start）に対応する閉じの次の位置。中の括弧は何段でもよい。升の区切り（\| でない |）までに閉じなければ undefined。 */
+const noteEnd = (text: string, start: number): number | undefined =>
+  text
+    .slice(start)
+    .split("")
+    .reduce<NoteScan>(
+      (scan, char, offset) => {
+        if (scan.end !== undefined || scan.stopped) return scan;
+        if (char === "|" && text[start + offset - 1] !== "\\") return { ...scan, stopped: true };
+        const depth = scan.depth + (OPENERS.has(char) ? 1 : 0) - (CLOSERS.has(char) ? 1 : 0);
+        return { depth, end: depth === 0 ? start + offset + 1 : undefined, stopped: false };
+      },
+      { depth: 0, end: undefined, stopped: false },
+    ).end;
+
+/**
+ * 見出しの語の後ろが見出しの終わりか。括弧の注記は飛ばして、その後ろを同じに読む。注記の後ろに語が続けば（Tax (10%) workshop、
+ * 合計（第1期）設計）、注記の付いた項目の名前。升の中で閉じない括弧は、そこからを注記とみなす。
+ */
+const endsLabel = (rest: string): boolean => {
+  const open = NOTE_OPEN.exec(rest);
+  if (open === null) return AFTER_LABEL.test(rest);
+  const end = noteEnd(rest, open[0].length - 1);
+  return end === undefined || endsLabel(rest.slice(end));
+};
 
 export const isTotalLabel = (text: string, labels: readonly string[]): boolean => {
   const lead = leadingText(text).toLowerCase();
-  return labels.some((label) => lead.startsWith(label.toLowerCase()) && AFTER_LABEL.test(lead.slice(label.length)));
+  return labels.some((label) => lead.startsWith(label.toLowerCase()) && endsLabel(lead.slice(label.length)));
 };
 
 const centsOf = (source: string, line: Line, amount: Amount): number | undefined => {

package/src/structure/versioned-label.ts

@@ -0,0 +1,52 @@
+/**
+ * A label naming the version it is about: the version after the label and a word (End of support for 5.0.0:), or before
+ * it with a word (3.0.0 のサポート終了日：). The words come from the language's lexicon; a version is digits joined by dots,
+ * with or without a leading v. Pure.
+ */
+
+/** The words that join a version to a label: after for the label, word, version order; before for version, word, label. */
+export type VersionWords = { readonly after: readonly string[]; readonly before: readonly string[] };
+
+/** A list marker, a table cell's bar and emphasis before the label. A numbered marker needs its space: 3.0.0 is a version, not item 3. */
+const LINE_LEAD = /^[ \t]*(?:(?:[-*+]|\d{1,3}[.)])[ \t]+)?(?:\|[ \t]*)?[*_]*/u;
+const VERSION = /^v?\d+(?:\.\d+)+/iu;
+/** After the label's version, only the label's end: a colon or a table cell's bar. */
+const VERSION_END = /^[ \t]*[:：|]/u;
+const SPACES = /^[ \t\u3000]*/u;
+
+const spacesAt = (text: string): number => SPACES.exec(text)?.[0].length ?? 0;
+
+const versionAt = (text: string): number => VERSION.exec(text)?.[0].length ?? 0;
+
+/** After the label: one word, spaces on both sides, a version and the label's end. Returns the label's end on. */
+const afterVersion = (rest: string, word: string): string | undefined => {
+  const gap = spacesAt(rest);
+  if (gap === 0 || !rest.slice(gap).toLowerCase().startsWith(`${word.toLowerCase()} `)) return undefined;
+  const from = gap + word.length + spacesAt(rest.slice(gap + word.length));
+  const version = versionAt(rest.slice(from));
+  const tail = rest.slice(from + version);
+  return version > 0 && VERSION_END.test(tail) ? tail : undefined;
+};
+
+/** Before the label: a version, the word and the label, spaces allowed between. Returns the text from the label on. */
+const beforeVersion = (lead: string, word: string, label: string): string | undefined => {
+  const version = versionAt(lead);
+  if (version === 0) return undefined;
+  const atWord = version + spacesAt(lead.slice(version));
+  if (!lead.slice(atWord).startsWith(word)) return undefined;
+  const atLabel = atWord + word.length + spacesAt(lead.slice(atWord + word.length));
+  return lead.slice(atLabel).toLowerCase().startsWith(label.toLowerCase()) ? lead.slice(atLabel) : undefined;
+};
+
+/**
+ * The line read as the bare label: "End of support for 5.0.0: …" as "End of support: …", "3.0.0 のサポート終了日：…" as
+ * "サポート終了日：…". undefined when the line does not start with the label carrying a version that way.
+ */
+export const withoutLabelVersion = (text: string, label: string, words: VersionWords): string | undefined => {
+  const lead = text.replace(LINE_LEAD, "");
+  const after = lead.toLowerCase().startsWith(label.toLowerCase())
+    ? words.after.map((word) => afterVersion(lead.slice(label.length), word)).find((tail) => tail !== undefined)
+    : undefined;
+  if (after !== undefined) return `${lead.slice(0, label.length)}${after}`;
+  return words.before.map((word) => beforeVersion(lead, word, label)).find((rest) => rest !== undefined);
+};

package/src/structure/written-headings.ts

@@ -0,0 +1,137 @@
+// 平文の契約の見出し。Markdown の見出しを使わない契約（.txt）は、行の頭や文の切れ目に「9. Indemnification.」
+// 「Section 2.3   Appraisal Shares.」と番号と題を書く。木は本文の番号と見分けられないのでこれを番地にしないが、
+// 参照の行き先としては読める。目次の行（「Section 2.3 Appraisal Shares 4」）は題が点で閉じないので見出しにしない。
+
+/** 書かれた見出し。address は参照の target と同じ形（「6.1」）。start は見出しの位置。 */
+export type WrittenHeading = { readonly address: string; readonly start: number };
+
+/** 参照の位置と行き先。木の reference の節点から取る。 */
+export type ReferenceSpan = { readonly start: number; readonly end: number; readonly target: string };
+
+/** 題の語の数の上限。見出しの題は短い。 */
+const MAX_TITLE_WORDS = 15;
+/** 題の語: 文字で始まり、文字・アポストロフィ・アンパサンド・ハイフンが続き、読点やセミコロンで終わってもよい。数字は入らない。 */
+const TITLE_WORD = /^\p{L}[\p{L}’'&-]*[,;]?$/u;
+const CAPITAL = /^\p{Lu}/u;
+
+/**
+ * Title Case の題か（「Effect on Capital Stock of the Company and Merger Sub」）。最初の語が大文字で始まり、語の半分より多くが
+ * 大文字で始まり、数字を含まない。文（「The Company shall comply」）は小文字の語が多いので当たらない。Pure.
+ */
+export const isTitle = (title: string): boolean => {
+  const words = title.trim().split(/\s+/u);
+  const [first] = words;
+  if (first === undefined || first === "" || words.length > MAX_TITLE_WORDS || !words.every((word) => TITLE_WORD.test(word))) return false;
+  return CAPITAL.test(first) && words.filter((word) => CAPITAL.test(word)).length * 2 > words.length;
+};
+
+/** 点で閉じた題（「Appraisal Shares. As used」の「Appraisal Shares」）。点の後ろは空白か行末。無ければ undefined。 */
+const MAX_TITLE_LENGTH = 120;
+const titleClosedByDot = (text: string): string | undefined => {
+  const dot = text.slice(0, MAX_TITLE_LENGTH).search(/\.(?:\s|$)/u);
+  return dot <= 0 ? undefined : text.slice(0, dot);
+};
+
+/** 前の語が番号（「Section 8.07. Section 16 Matters」の 8.07.）なら、後ろはその見出しの題で、見出しではない。 */
+const NUMBER_BEFORE = /\d[.:]?$/u;
+const SENTENCE_END = /[.;:]$/u;
+const isSpace = (char: string | undefined): boolean => char === " " || char === "\t";
+
+/** 見出しが始まれる位置: 行の頭、文の終わり（. ; :）の後ろの空白、2 つ以上の空白の後ろ。前が番号なら始まらない。 */
+const startsHeading = (source: string, at: number): boolean => {
+  const before = source.slice(Math.max(source.lastIndexOf("\n", at - 1) + 1, at - MAX_TITLE_LENGTH), at);
+  let spaces = 0;
+  while (isSpace(before[before.length - 1 - spaces])) spaces += 1;
+  if (spaces === before.length) return true;
+  const word =
+    before
+      .slice(0, before.length - spaces)
+      .split(/[ \t]/u)
+      .at(-1) ?? "";
+  if (NUMBER_BEFORE.test(word)) return false;
+  return spaces >= 2 || (spaces >= 1 && SENTENCE_END.test(word));
+};
+
+/** 参照のすぐ後ろが題か（「Section 4.12. Compliance with Laws.」「Section 1.1      Closing. The Parties」）。 */
+const NUMBER_CLOSE = /^\.?[ \t]+/u;
+/** 番号と題のあいだの空白の長さの上限（データセットの契約は十数個の空白を置く）。 */
+const MAX_NUMBER_CLOSE = 24;
+const titledAfter = (source: string, end: number): boolean => {
+  const rest = source.slice(end, end + MAX_TITLE_LENGTH + MAX_NUMBER_CLOSE);
+  const close = NUMBER_CLOSE.exec(rest)?.[0];
+  const title = close === undefined ? undefined : titleClosedByDot(rest.slice(close.length));
+  return title !== undefined && isTitle(title);
+};
+
+/** 参照の形で書かれた見出し（「… Effect. Section 4.12. Compliance with Laws.」）。 */
+const headingsAtReferences = (references: readonly ReferenceSpan[], source: string): WrittenHeading[] =>
+  references
+    .filter((reference) => startsHeading(source, reference.start) && titledAfter(source, reference.end))
+    .map((reference) => ({ address: reference.target, start: reference.start }));
+
+/** 行の頭の番号（「9. Indemnification.」「4 Intellectual Property. 4.1 Each」「6.1 eGain warrants」「2 Quality and Food Safety」）。 */
+const LINE_NUMBER = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})\.?[ \t]+(?<rest>\S.*)$/u;
+/** 語のどこかに大文字があるか（「eGain」も名前）。 */
+const HAS_CAPITAL = /\p{Lu}/u;
+
+/**
+ * 行の頭の番号が見出しか。題が点で閉じ、同じ行に本文が続けば見出し（「9. Indemnification. Each party …」）。題だけの行
+ * （「1. Introduction」）は箇条書きと見分けられないので読まない。点を含む番号（6.1）は、最初の語に大文字があり、題より長い
+ * 段落が続けば段落の番号（「6.1 eGain warrants …」）。本文の折り返しの「2.5 percent」は小文字、目次の「3.17 Reserves 33」は短いので当たらない。
+ */
+const isLineHeading = (number: string, rest: string): boolean => {
+  const title = titleClosedByDot(rest);
+  if (title !== undefined && rest.slice(title.length + 1).trim() !== "" && isTitle(title)) return true;
+  const words = rest.split(/\s+/u);
+  return number.includes(".") && words.length > MAX_TITLE_WORDS && HAS_CAPITAL.test(words[0] ?? "");
+};
+
+const headingsAtLineStarts = (source: string): WrittenHeading[] => {
+  const found: WrittenHeading[] = [];
+  let start = 0;
+  source.split("\n").forEach((line) => {
+    const groups = LINE_NUMBER.exec(line)?.groups;
+    const number = groups?.["number"];
+    if (number !== undefined && isLineHeading(number, groups?.["rest"] ?? "")) found.push({ address: number, start });
+    start += line.length + 1;
+  });
+  return found;
+};
+
+/** 文書に平文で書かれた見出しを、文書の順に。Pure. */
+export const writtenHeadings = (references: readonly ReferenceSpan[], source: string): WrittenHeading[] =>
+  [...headingsAtReferences(references, source), ...headingsAtLineStarts(source)].toSorted((left, right) => left.start - right.start);
+
+/** 括弧の小見出し（「(i)」「(b)」「(3)」）。参照の一部（「Section 2.02(b)」「(a)(i)」）は、前が文字・数字・括弧なので読まない。 */
+const SUBDIVISION_LABEL = /(?<![\p{L}\p{N})\]])\((?<label>[a-zA-Z]{1,4}|\d{1,3})\)/gu;
+
+/** 本文に書かれた括弧の小見出しの札。Pure. */
+export const writtenSubdivisions = (body: string): ReadonlySet<string> =>
+  new Set([...body.matchAll(SUBDIVISION_LABEL)].flatMap((match) => (match.groups?.["label"] === undefined ? [] : [match.groups["label"]])));
+
+/** 参照の札（「Section 2.1(a)(i)」の a と i）。 */
+const LABEL_IN_REFERENCE = /\((?<label>[a-zA-Z]{1,4}|\d{1,3})\)/gu;
+
+/**
+ * 参照の番地「2.1.a.i」を、親「2.1」と、参照が括弧で書いた札「a」「i」に分ける。札を括弧で書いていない参照（Section 2.1）や、
+ * 番地の末尾が書いた札と合わなければ undefined。Pure.
+ */
+export const parentAndLabels = (target: string, written: string): { readonly parent: string; readonly labels: readonly string[] } | undefined => {
+  const labels = [...written.matchAll(LABEL_IN_REFERENCE)].flatMap((match) => (match.groups?.["label"] === undefined ? [] : [match.groups["label"]]));
+  const parts = target.split(".");
+  const cut = parts.length - labels.length;
+  if (labels.length === 0 || cut <= 0 || parts.slice(cut).join(".") !== labels.join(".")) return undefined;
+  return { parent: parts.slice(0, cut).join("."), labels };
+};
+
+/** 書かれた見出しごとの範囲（次の書かれた見出しまで）。同じ番地が二度あれば、どちらの範囲もその番地のもの。Pure. */
+export const headingRegions = (headings: readonly WrittenHeading[], length: number): ReadonlyMap<string, readonly (readonly [number, number])[]> => {
+  const regions = new Map<string, (readonly [number, number])[]>();
+  headings.forEach((heading, index) => {
+    const end = headings[index + 1]?.start ?? length;
+    const found = regions.get(heading.address) ?? [];
+    found.push([heading.start, end]);
+    regions.set(heading.address, found);
+  });
+  return regions;
+};

package/src/structure/written-resolve.ts

@@ -0,0 +1,57 @@
+import type { StructureNode } from "../plugin.ts";
+import { headingRegions, parentAndLabels, writtenHeadings, writtenSubdivisions, type WrittenHeading } from "./written-headings.ts";
+
+// 木が番地にしない平文の見出しと、本文の中に書いた括弧の小見出し（「6.1 … that (i) the Software …」）を、参照の行き先として引く。
+
+type Region = readonly [number, number];
+
+/** addresses: 平文で書かれた見出しの番地。subdivision: 参照の札が、親の範囲の本文に書かれているか。 */
+export type WrittenReading = { readonly addresses: readonly string[]; readonly subdivision: (reference: StructureNode) => boolean };
+
+const targetOf = (node: StructureNode): string => String(node.attrs["target"] ?? "");
+
+/**
+ * 括弧の小見出しを読む範囲。木の条は、項や号を一つも読まなかったときだけ、その条の始まりから次の平文の見出しまで。
+ * 項や号を読んでいれば、無い札は本当に無い。
+ */
+const treeRegions = (nodes: readonly StructureNode[], headings: readonly WrittenHeading[]): Map<string, Region[]> => {
+  const regions = new Map<string, Region[]>();
+  // 条も見出しも文書の順なので、次の見出しは前へ進めるだけで見つかる。
+  let next = 0;
+  nodes
+    .filter((node) => node.kind === "article" && !node.children.some((child) => child.kind === "item"))
+    .toSorted((left, right) => left.span.start - right.span.start)
+    .forEach((node) => {
+      while ((headings[next]?.start ?? Infinity) <= node.span.start) next += 1;
+      const end = Math.min(headings[next]?.start ?? node.span.end, node.span.end);
+      const found = regions.get(node.address) ?? [];
+      found.push([node.span.start, end]);
+      regions.set(node.address, found);
+    });
+  return regions;
+};
+
+/**
+ * 平文の見出しの番地と、参照（Section 6.1(i)）の親（6.1）が木の条か平文の見出しとしてあり、その範囲の本文に札「(i)」が
+ * 書かれているかを引く関数。範囲ごとの札は、要るときに一度だけ読む。Pure.
+ */
+export const writtenReading = (nodes: readonly StructureNode[], source: string): WrittenReading => {
+  const references = nodes.filter((node) => node.kind === "reference").map((node) => ({ start: node.span.start, end: node.span.end, target: targetOf(node) }));
+  const headings = writtenHeadings(references, source);
+  const written = headingRegions(headings, source.length);
+  const tree = treeRegions(nodes, headings);
+  const labels = new Map<string, ReadonlySet<string>>();
+  const labelsIn = ([start, end]: Region): ReadonlySet<string> => {
+    const key = `${String(start)}:${String(end)}`;
+    const found = labels.get(key) ?? writtenSubdivisions(source.slice(start, end));
+    labels.set(key, found);
+    return found;
+  };
+  const regionsOf = (address: string): Region[] => [...(tree.get(address) ?? []), ...(written.get(address) ?? [])];
+  const subdivision = (reference: StructureNode): boolean => {
+    const wanted = parentAndLabels(targetOf(reference), String(reference.attrs["label"] ?? ""));
+    if (wanted === undefined) return false;
+    return regionsOf(wanted.parent).some((region) => wanted.labels.every((label) => labelsIn(region).has(label)));
+  };
+  return { addresses: headings.map((heading) => heading.address), subdivision };
+};

package/src/subject-codes.ts

@@ -0,0 +1,105 @@
+// The one code a product document is about (a recall's or a warranty's model): named in its title, or labelled on a line
+// of its own or in a table (型番：NH-805, | Model | MW-4120S |), and written once elsewhere with two neighbours swapped
+// (NH-850). Only when the document names no other code in those places: a catalog naming two is about two items. Pure.
+import type { LexiconEntry, Span } from "./plugin.ts";
+import { labelBefore, swapsNeighbours, withoutUrls } from "./phone-numbers.ts";
+import { charactersOf, LABEL_TO_NUMBER, REFERENCE_SHAPE, type ReferenceNumber, type ReferenceVariant } from "./reference-numbers.ts";
+import { isCodeWith } from "./unlabelled-references.ts";
+
+/** Digits enough for a model's code (FT-38); the two letters a short code must hold keep out form names (A-12, B-21). */
+export const MIN_SUBJECT_DIGITS = 2;
+const MIN_SUBJECT_LETTERS = 2;
+const LETTER = /[A-Z]/gu;
+const FIRST_PART = /^[^-‐−－]*/u;
+const TITLE_GROUP = "title";
+
+/** A short code: two letters or more before its hyphen, and two digits or more (FT-38, KR-M230; not A-12B). */
+export const isSubjectCode = (written: string): boolean =>
+  isCodeWith(MIN_SUBJECT_DIGITS)(written) && (charactersOf(FIRST_PART.exec(written)?.[0] ?? "").match(LETTER)?.length ?? 0) >= MIN_SUBJECT_LETTERS;
+
+/** What the document gives: its prose (tables masked), its title as written (the prose masks it), its labels, the groups that name an item, the codes its tables label, and every code in a table. */
+export type SubjectCodeInput = {
+  readonly prose: string;
+  readonly title: { readonly start: number; readonly text: string } | undefined;
+  readonly labels: readonly LexiconEntry[];
+  readonly listed: ReadonlySet<string>;
+  readonly tabled: readonly ReferenceNumber[];
+  readonly known: ReadonlySet<string>;
+};
+
+type CodeWriting = ReferenceNumber & { readonly anchor: boolean; readonly group: string | undefined };
+
+const lineAround = (text: string, offset: number): Span => {
+  const start = text.lastIndexOf("\n", offset - 1) + 1;
+  const end = text.indexOf("\n", offset);
+  return { start, end: end === -1 ? text.length : end };
+};
+
+/** Whether a code's line holds a label of the given labels, the separators and the code, and nothing else (型番：NH-805). */
+const isFieldLine = (text: string, offset: number, written: string, between: string, labels: readonly LexiconEntry[]): boolean => {
+  const line = lineAround(text, offset);
+  const head = text
+    .slice(line.start, offset - between.length)
+    .trim()
+    .toLowerCase();
+  const rest = text.slice(offset + written.length, line.end).trim();
+  return rest === "" && labels.some((label) => label.pattern.toLowerCase() === head);
+};
+
+const shortCodes = (text: string): RegExpExecArray[] => [...text.matchAll(REFERENCE_SHAPE)].filter((match) => isSubjectCode(match[0]));
+
+/** Every short code of the title, each an anchor. */
+const titleWritings = (title: SubjectCodeInput["title"]): CodeWriting[] =>
+  title === undefined
+    ? []
+    : shortCodes(title.text).map((match) => ({
+        offset: title.start + match.index,
+        written: match[0],
+        characters: charactersOf(match[0]),
+        label: TITLE_GROUP,
+        anchor: true,
+        group: undefined,
+      }));
+
+/** Every short code of the prose, as an anchor when a field line of a listed kind labels it. */
+const proseWritings = (text: string, input: SubjectCodeInput): CodeWriting[] =>
+  shortCodes(text).map((match) => {
+    const written = match[0];
+    const offset = match.index;
+    const label = labelBefore(text, offset, input.labels);
+    const group = label !== undefined && LABEL_TO_NUMBER.test(label.between) ? label.group : undefined;
+    const onField = group !== undefined && input.listed.has(group) && isFieldLine(text, offset, written, label?.between ?? "", input.labels);
+    return { offset, written, characters: charactersOf(written), label: group ?? TITLE_GROUP, anchor: onField, group };
+  });
+
+/** The title's codes and the prose's, one writing per place. */
+const writingsOf = (text: string, input: SubjectCodeInput): CodeWriting[] => {
+  const inTitle = titleWritings(input.title);
+  return [...inTitle, ...proseWritings(text, input).filter((writing) => !inTitle.some((title) => title.offset === writing.offset))];
+};
+
+/** The writings of the document's one code with two neighbours swapped, each written once, of a listed kind or unlabelled, on a line that does not name the code itself. */
+export const subjectCodeVariants = (input: SubjectCodeInput): ReferenceVariant[] => {
+  const text = withoutUrls(input.prose);
+  const writings = writingsOf(text, input);
+  const anchors = [
+    ...writings.filter((writing) => writing.anchor),
+    ...input.tabled.filter((code) => input.listed.has(code.label) && isSubjectCode(code.written)),
+  ];
+  const subject = anchors[0];
+  if (subject === undefined || anchors.some((anchor) => anchor.characters !== subject.characters)) return [];
+  const timesWritten = (characters: string): number => writings.filter((writing) => writing.characters === characters).length;
+  return writings.flatMap((writing) => {
+    const line = lineAround(text, writing.offset);
+    const slip =
+      !writing.anchor &&
+      (writing.group === undefined || input.listed.has(writing.group)) &&
+      !input.known.has(writing.characters) &&
+      timesWritten(writing.characters) === 1 &&
+      swapsNeighbours(subject.characters, writing.characters) &&
+      !writings.some((other) => other.characters === subject.characters && other.offset >= line.start && other.offset < line.end);
+    if (!slip) return [];
+    const { offset, written, characters } = writing;
+    return [{ number: { offset, written, characters, label: subject.label }, other: subject }];
+  });
+};

package/src/unlabelled-references.ts

@@ -8,16 +8,22 @@ import { withoutEdgeMarks } from "./facts/trim-marks.ts";
 import { charactersOf, MAX_CHARACTERS, MIN_DIGITS, REFERENCE_SHAPE, type ReferenceNumber, type ReferenceVariant } from "./reference-numbers.ts";
 
 const SEPARATOR = /[-‐−－]/u;
+
+type CodeShape = (written: string) => boolean;
 const LATIN_LETTER = /[A-Z]/u;
 const DIGIT = /\d/gu;
 
-/** A code: letters, a hyphen and four digits or more (GP-0512). A plain number (48215, 2026-118) is never one. */
-const isCode = (written: string): boolean => {
-  const characters = charactersOf(written);
-  return (
-    SEPARATOR.test(written) && LATIN_LETTER.test(characters) && (characters.match(DIGIT)?.length ?? 0) >= MIN_DIGITS && characters.length <= MAX_CHARACTERS
-  );
-};
+/** A code: letters, a hyphen and the given digits or more (GP-0512). A plain number (48215, 2026-118) is never one. */
+export const isCodeWith =
+  (minDigits: number) =>
+  (written: string): boolean => {
+    const characters = charactersOf(written);
+    return (
+      SEPARATOR.test(written) && LATIN_LETTER.test(characters) && (characters.match(DIGIT)?.length ?? 0) >= minDigits && characters.length <= MAX_CHARACTERS
+    );
+  };
+
+const isCode = isCodeWith(MIN_DIGITS);
 
 const keyOf = (text: string): string => withoutEdgeMarks(text).normalize("NFKC").toLowerCase();
 
@@ -29,10 +35,10 @@ const labelOfCell = (cell: Cell | undefined, labels: readonly LexiconEntry[]): s
 };
 
 /** A cell holding one code and nothing else, as a reference number of the group. */
-const codeOfCell = (cell: Cell | undefined, group: string): ReferenceNumber[] => {
+const codeOfCell = (cell: Cell | undefined, group: string, isCodeShape: CodeShape): ReferenceNumber[] => {
   if (cell === undefined) return [];
   const written = withoutEdgeMarks(cell.text);
-  if (!isCode(written) || [...written.matchAll(REFERENCE_SHAPE)].length !== 1) return [];
+  if (!isCodeShape(written) || [...written.matchAll(REFERENCE_SHAPE)].length !== 1) return [];
   return [{ offset: cell.start + cell.text.indexOf(written), written, characters: charactersOf(written), label: group }];
 };
 
@@ -40,28 +46,30 @@ const codeOfCell = (cell: Cell | undefined, group: string): ReferenceNumber[] =>
  * The codes a table labels: in a row whose first cell is a label (| 品番 | GP-0512 |), and in a column whose heading is
  * one (| 品番 | 品名 | over | GP-0512 | …). Pass the text with its tables (proseAndTablesOf).
  */
-export const tableLabelledCodes = (text: string, labels: readonly LexiconEntry[]): ReferenceNumber[] =>
+export const tableLabelledCodes = (text: string, labels: readonly LexiconEntry[], isCodeShape: CodeShape = isCode): ReferenceNumber[] =>
   tablesOf(linesOf(text)).flatMap((table) => {
     const headings = cellsOf(table.header).map((cell) => labelOfCell(cell, labels));
     return table.rows.flatMap((row) => {
       const cells = cellsOf(row);
       const rowGroup = labelOfCell(cells[0], labels);
-      const byRow = rowGroup === undefined ? [] : codeOfCell(cells[1], rowGroup);
+      const byRow = rowGroup === undefined ? [] : codeOfCell(cells[1], rowGroup, isCodeShape);
       const byColumn = cells.flatMap((cell, index) => {
         const group = headings[index];
-        return group === undefined ? [] : codeOfCell(cell, group);
+        return group === undefined ? [] : codeOfCell(cell, group, isCodeShape);
       });
       return [...byRow, ...byColumn];
     });
   });
 
 /** The letters and digits of every code a cell holds. */
-const codesInCell = (cell: Cell): string[] =>
-  [...cell.text.matchAll(REFERENCE_SHAPE)].filter((match) => isCode(match[0])).map((match) => charactersOf(match[0]));
+const codesInCell = (cell: Cell, isCodeShape: CodeShape): string[] =>
+  [...cell.text.matchAll(REFERENCE_SHAPE)].filter((match) => isCodeShape(match[0])).map((match) => charactersOf(match[0]));
 
 /** Every code written anywhere in a table, its heading row too, labelled or not: a code a table lists is an item of its own, never a slip. */
-export const tableCodes = (text: string): Set<string> =>
-  new Set(tablesOf(linesOf(text)).flatMap((table) => [table.header, ...table.rows].flatMap((row) => cellsOf(row).flatMap(codesInCell))));
+export const tableCodes = (text: string, isCodeShape: CodeShape = isCode): Set<string> =>
+  new Set(
+    tablesOf(linesOf(text)).flatMap((table) => [table.header, ...table.rows].flatMap((row) => cellsOf(row).flatMap((cell) => codesInCell(cell, isCodeShape)))),
+  );
 
 /**
  * Every code of the prose written with no label that is one labelled code with two neighbours swapped. Only when exactly