chaffjs 0.32.0 → 0.34.0

package/src/structure/start-end-range.ts

@@ -0,0 +1,120 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { Lexicon } from "../plugin.ts";
+import { bare, withoutTrailingWeekday, type DatedSpan } from "./date-range.ts";
+
+/**
+ * 始まりの語と終わりの語で書いた期間（The term starts on 1 April 2026 and ends on 31 March 2027、2026年4月1日から開始し、2027年3月31日に終了する）。
+ * 一つ目の日付に始まりの語が、二つ目の日付に終わりの語が付き、二つの日付の間は付いた語とつなぎの語だけ。
+ * 文に始まりの語か終わりの語が二つあれば、どの日付がどの期間のものか決まらないので読まない。語は語彙表（range-start-end）から受け取る。
+ */
+export type StartEndWord = { readonly word: string; readonly position: "before" | "after" };
+
+export type StartEndWords = {
+  readonly starts: readonly StartEndWord[];
+  readonly ends: readonly StartEndWord[];
+  /** 始まりの語と終わりの語の間に立つ語（and、and shall、し、）。 */
+  readonly joints: readonly string[];
+  /**
+   * 終わりの日付の後ろに付く終わりの語（に終了）の、さらに後ろに来てよい語（する、し、）。「、」で終わる語は文が続くので頭だけを照らし、
+   * ほかは文の終わりまでがその語だけ。「に終了した旧契約」は名詞にかかる語で、期間の終わりではない。
+   */
+  readonly tails: readonly string[];
+  readonly weekdays: readonly string[];
+};
+
+/** 文の終わり。英語は後ろが大文字のときだけ（"in Jan. 2026" は切らない）。段落の切れ目も文の終わり。 */
+const SENTENCE_END = /[。！？]|[.!?]\s+(?=[A-Z])|\n\s*\n/gu;
+
+const flat = (text: string): string => text.replace(/\s+/gu, " ").toLowerCase();
+
+const LATIN = /[a-z]/u;
+
+/** 英字の語は語の切れ目で照らす（ends が depends に当たらない）。英字で始まらない・終わらない語は、その側を照らさない。 */
+const wordPattern = (word: string, flags: string): RegExp => {
+  const head = LATIN.test(word.charAt(0)) ? "(?<![a-z])" : "";
+  const tail = LATIN.test(word.at(-1) ?? "") ? "(?![a-z])" : "";
+  return new RegExp(`${head}${escapeRegExp(word)}${tail}`, flags);
+};
+
+const endsWithWord = (text: string, word: string): boolean => new RegExp(`${wordPattern(word, "u").source}$`, "u").test(text);
+
+const startsWithWord = (text: string, word: string): boolean => new RegExp(`^${wordPattern(word, "u").source}`, "u").test(text);
+
+/** 文の中で、語のどれかに当たる所の数。重なる当たり（starts と starts on）は一つ。 */
+export const occurrences = (text: string, words: readonly StartEndWord[]): number => {
+  const spans = words
+    .flatMap(({ word }) => [...text.matchAll(wordPattern(word, "gu"))].map((match) => ({ start: match.index, end: match.index + match[0].length })))
+    .toSorted((left, right) => left.start - right.start || right.end - left.end);
+  return spans.reduce(
+    (acc, span) => (span.start >= acc.end ? { count: acc.count + 1, end: span.end } : { count: acc.count, end: Math.max(acc.end, span.end) }),
+    {
+      count: 0,
+      end: -1,
+    },
+  ).count;
+};
+
+type Sentence = { readonly before: string; readonly between: string; readonly after: string; readonly whole: string };
+
+/** 二つの日付を含む文を、始まりの日付の前、二つの日付の間、終わりの日付の後ろに分ける。間に文の終わりがあれば undefined。 */
+const sentenceOf = (source: string, start: DatedSpan, end: DatedSpan): Sentence | undefined => {
+  const between = source.slice(start.end, end.offset);
+  if (new RegExp(SENTENCE_END.source, "u").test(between)) return undefined;
+  const from = [...source.slice(0, start.offset).matchAll(SENTENCE_END)].map((match) => match.index + match[0].length).at(-1) ?? 0;
+  const tail = source.slice(end.end);
+  const to = end.end + ([...tail.matchAll(SENTENCE_END)][0]?.index ?? tail.length);
+  const before = flat(source.slice(from, start.offset)).trimEnd();
+  const after = bare(source.slice(end.end, to));
+  return { before, between: bare(between), after, whole: flat(source.slice(from, to)) };
+};
+
+const beforeWord = (text: string, words: readonly StartEndWord[]): string | undefined =>
+  words.find((entry) => entry.position === "before" && endsWithWord(text, entry.word))?.word;
+
+const afterWord = (text: string, words: readonly StartEndWord[]): string | undefined =>
+  words.find((entry) => entry.position === "after" && startsWithWord(text, entry.word))?.word;
+
+const endsPredicate = (rest: string, tails: readonly string[]): boolean => tails.some((tail) => (tail.endsWith("、") ? rest.startsWith(tail) : rest === tail));
+
+/** 終わりの日付の後ろの終わりの語で、その後ろが述語の終わり（に終了する。に終了し、）。 */
+const endAfterWord = (after: string, words: StartEndWords): string | undefined => {
+  const word = afterWord(after, words.ends);
+  return word !== undefined && endsPredicate(after.slice(word.length).trim(), words.tails) ? word : undefined;
+};
+
+/** 間の語から、始まりの日付の後ろの語と終わりの日付の前の語を除いた残りが、つなぎの語か。 */
+const joinedBetween = (between: string, words: StartEndWords, startAfter: string | undefined, endBefore: string | undefined): boolean => {
+  const head = startAfter === undefined ? between : between.slice(startAfter.length).trimStart();
+  const rest = endBefore === undefined ? head : head.slice(0, head.length - endBefore.length).trimEnd();
+  return words.joints.some((joint) => joint.toLowerCase() === rest);
+};
+
+/** 二つの日付が、始まりの語と終わりの語で書いた一つの期間か。 */
+export const isStartEndRange = (source: string, start: DatedSpan, end: DatedSpan, words: StartEndWords): boolean => {
+  const sentence = sentenceOf(source, start, end);
+  if (sentence === undefined) return false;
+  if (occurrences(sentence.whole, words.starts) !== 1 || occurrences(sentence.whole, words.ends) !== 1) return false;
+  const between = withoutTrailingWeekday(sentence.between, words.weekdays);
+  const startBefore = beforeWord(withoutTrailingWeekday(sentence.before, words.weekdays), words.starts);
+  const startAfter = afterWord(between, words.starts);
+  const endBefore = beforeWord(between, words.ends);
+  const endAfter = endAfterWord(sentence.after, words);
+  if ((startBefore ?? startAfter) === undefined || (endBefore ?? endAfter) === undefined) return false;
+  return joinedBetween(between, words, startAfter, endBefore);
+};
+
+const wordsIn = (entries: Lexicon, group: "start" | "end"): StartEndWord[] =>
+  entries
+    .filter((entry) => entry.group === group)
+    .map((entry) => ({ word: entry.pattern.toLowerCase(), position: entry.position === "after" ? "after" : "before" }));
+
+const patternsIn = (entries: Lexicon, group: string): string[] => entries.filter((entry) => entry.group === group).map((entry) => entry.pattern.toLowerCase());
+
+/** 語彙表 range-start-end の行を、group（start、end、joint、tail）で分ける。 */
+export const startEndWordsOf = (entries: Lexicon, weekdays: readonly string[]): StartEndWords => ({
+  starts: wordsIn(entries, "start"),
+  ends: wordsIn(entries, "end"),
+  joints: patternsIn(entries, "joint"),
+  tails: patternsIn(entries, "tail"),
+  weekdays,
+});

package/src/structure/tax.ts

@@ -1,6 +1,6 @@
 import type { StructureIssue } from "./issues.ts";
 import { runsOf, type Line } from "./runs.ts";
-import { columnOf, isTotalLabel, shownTotal, type Amount } from "./total.ts";
+import { columnOf, isTotalLabel, shownTotal, withoutLeadingBlankCells, type Amount } from "./total.ts";
 
 /**
  * 税の行と、その上の金額に率を掛けた額。表か箇条書きの並びで、税の語（消費税・Sales tax）で始まり率（10%）を書いた行の
@@ -42,8 +42,11 @@ const rateOf = (text: string): number | undefined => {
   return Number.isFinite(rate) && rate > 0 && rate < MAX_RATE ? rate : undefined;
 };
 
+/** A tax or total row may leave its first cells blank and put its word in the first cell that is not (| | 小計 | 12,000円 |). */
+const startsWithLabel = (row: Row, labels: readonly string[]): boolean => isTotalLabel(withoutLeadingBlankCells(row.text), labels);
+
 const isTaxRow = (row: Row, words: TaxWords): boolean =>
-  isTotalLabel(row.text, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
+  startsWithLabel(row, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
 
 const isChargeRow = (row: Row, words: TaxWords): boolean => isTotalLabel(row.text, words.charges) && rateOf(row.text) !== undefined;
 
@@ -89,7 +92,7 @@ const basesOf = (source: string, above: readonly Row[], tax: Amount, column: num
   const charges = valuesAt(source, above.slice(chargeStart), column, tax.unit);
   if (charges === undefined) return [];
   const before = above.slice(0, chargeStart);
-  const lastTotalIndex = before.findLastIndex((row) => isTotalLabel(row.text, words.totals));
+  const lastTotalIndex = before.findLastIndex((row) => startsWithLabel(row, words.totals));
   const lastTotal = before[lastTotalIndex];
   if (lastTotal !== undefined) {
     const total = amountAt(source, lastTotal, column, tax.unit);

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/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