chaffjs 0.34.0 → 0.36.0

package/src/facts/table-facts.ts

@@ -67,18 +67,21 @@ const cellLabel = (rowLabel: string, column: string, headings: readonly string[]
   return headings.length > TWO_COLUMNS ? `${rowLabel} ${column}` : rowLabel;
 };
 
-/** 列が三つ以上の表の升は、行の見出し（row）と列の見出し（column）の二つで名前になる。 */
-export type TableFact = Fact & { readonly cell?: { readonly row: string; readonly column: string } };
+/**
+ * 列が三つ以上の表の升は、行の見出し（row）と列の見出し（column）の二つで名前になる。
+ * columnGroup: 見出しの並びを繰り返す表（Day | Hours | Day | Hours の、第1週と第2週を横に並べた表）の、何番目の並びの升か。
+ */
+export type TableFact = Fact & { readonly cell?: { readonly row: string; readonly column: string }; readonly columnGroup?: number };
 
 const rowFacts = (
-  row: Line,
+  cells: readonly Cell[],
   headings: readonly string[],
   values: readonly FactValue[],
   source: string,
   totals?: TotalColumns,
   counts?: CountLabelWords,
 ): TableFact[] => {
-  const [first, ...rest] = cellsOf(row);
+  const [first, ...rest] = cells;
   if (first === undefined) return [];
   const rowLabel = plain(first.text);
   const isCountHead = (value: FactValue): boolean => counts !== undefined && isCountLabelHead(source, first, value, counts);
@@ -94,11 +97,45 @@ const rowFacts = (
   });
 };
 
+const MIN_GROUPS = 2;
+
+/** 見出しが同じ並びを二度以上繰り返すなら、その並びの幅。並びごとに別の表として読む。 */
+export const columnGroupWidth = (headings: readonly string[]): number | undefined => {
+  const keys = headings.map(keyOf);
+  const widths = Array.from({ length: Math.floor(keys.length / MIN_GROUPS) - 1 }, (_, index) => index + TWO_COLUMNS);
+  return widths.find((width) => keys.length % width === 0 && keys[0] !== "" && keys.every((key, index) => key === keys[index % width]));
+};
+
+const groupsOf = <T>(items: readonly T[], width: number | undefined): T[][] =>
+  width === undefined ? [[...items]] : Array.from({ length: Math.ceil(items.length / width) }, (_, index) => items.slice(index * width, (index + 1) * width));
+
+/** columnGroups: 見出しを繰り返す表を、並びごとに読む（並びの升には columnGroup が付く）。 */
+export type TableReading = { readonly columnGroups?: boolean };
+
+type RowReading = { readonly values: readonly FactValue[]; readonly source: string; readonly totals?: TotalColumns; readonly counts?: CountLabelWords };
+
+/** 一つの行の升の値。見出しを繰り返す表（width がある）は、並びごとに読んで columnGroup を付ける。 */
+const groupedRowFacts = (row: Line, headings: readonly string[], width: number | undefined, at: RowReading): TableFact[] => {
+  const headingGroups = groupsOf(headings, width);
+  return groupsOf(cellsOf(row), width).flatMap((cells, group) => {
+    const facts = rowFacts(cells, headingGroups[group] ?? [], at.values, at.source, at.totals, at.counts);
+    return width === undefined ? facts : facts.map((fact) => ({ ...fact, columnGroup: group }));
+  });
+};
+
 /** 文書の表すべての升の値。 */
-export const tableFacts = (source: string, values: readonly FactValue[], totals?: TotalColumns, counts?: CountLabelWords): TableFact[] =>
+export const tableFacts = (
+  source: string,
+  values: readonly FactValue[],
+  totals?: TotalColumns,
+  counts?: CountLabelWords,
+  reading: TableReading = {},
+): TableFact[] =>
   tablesOf(linesOf(source)).flatMap((table) => {
     const headings = cellsOf(table.header).map((cell) => plain(cell.text));
-    return table.rows.flatMap((row) => rowFacts(row, headings, values, source, totals, counts));
+    const width = reading.columnGroups === true ? columnGroupWidth(headings) : undefined;
+    const at: RowReading = { values, source, ...(totals === undefined ? {} : { totals }), ...(counts === undefined ? {} : { counts }) };
+    return table.rows.flatMap((row) => groupedRowFacts(row, headings, width, at));
   });
 
 /** 文書の表すべての、本体の行の升（見出しの行を除く）。text は書いたまま。 */

package/src/figure-references.ts

@@ -1,6 +1,7 @@
 import { escapeRegExp } from "./orthography.ts";
 import { lowerBound } from "./detectors/token-column.ts";
 import type { DocumentNamer, Span } from "./plugin.ts";
+import { isTitleLine, type TitleNotion } from "./title-line.ts";
 
 /**
  * 本文で番号を指した図・表・付録（図3、Table 2、Appendix B）と、それを行の頭に書いた所（キャプション、見出し）。
@@ -79,16 +80,20 @@ const HEADING = /^[ \t]{0,3}#/u;
  */
 const CAPTION_AFTER = /^(?:[ \t]*$|[:：.．—–\-|()（）【】\]*_]|[ \t\u3000]+[^\p{Script=Hiragana}\p{Ll}])/u;
 
+/** A caption's title (Exhibit A to Merger Agreement): every long word capitalised, since Figure 3 shows the trend is a sentence. */
+export const CAPTION_TITLE: TitleNotion = { sentenceEnd: /[.!?。．？！]$/u, capitalised: true, edge: "any-whitespace" };
+
 /**
  * 行の頭に書いた番号。前にあるのが飾り（#、**、![、|、【、箇条書きの印）だけで、見出しの中か、後ろが題の区切りならキャプション。
- * 行の頭から始まる本文の文（図３の例では、…）は、図の置き場所ではない。
+ * 行の頭から始まる本文の文（図３の例では、…）は、図の置き場所ではない。題だけの行（Exhibit A to Merger Agreement）も見出し。
  */
 const isLabelled = (source: string, mention: Mention): boolean => {
   const lineStart = source.lastIndexOf("\n", mention.start - 1) + 1;
   const lineEnd = source.indexOf("\n", mention.end);
   const before = source.slice(lineStart, mention.start);
   if (LETTER.test(outsideMarkup(before))) return false;
-  return HEADING.test(before) || CAPTION_AFTER.test(source.slice(mention.end, lineEnd === -1 ? source.length : lineEnd));
+  const rest = source.slice(mention.end, lineEnd === -1 ? source.length : lineEnd);
+  return HEADING.test(before) || CAPTION_AFTER.test(rest) || isTitleLine(source, lineStart, lineEnd, rest, CAPTION_TITLE);
 };
 
 const LATIN_WORD = /^[A-Za-z]/u;

package/src/format-template.ts

@@ -0,0 +1,15 @@
+// A code block that holds only a format template: named placeholders joined by separators (<MAJOR>.<MINOR>.<PATCH>,
+// {year}-{month}). It shows the shape of a value, not code in any language, so it has no language to name. Pure.
+
+const PLACEHOLDER = /<[A-Za-z][\w-]*>|\{[A-Za-z][\w-]*\}/gu;
+const SEPARATORS = /^\s*[.,:;/_+\-|][\s.,:;/_+\-|]*$/u;
+/** A lone tag (`<div>`) or two tags side by side are markup; a template joins two or more parts with a separator. */
+const MIN_PARTS = 2;
+
+const isTemplateLine = (line: string): boolean => (line.match(PLACEHOLDER) ?? []).length >= MIN_PARTS && SEPARATORS.test(line.replace(PLACEHOLDER, ""));
+
+/** Whether every non-blank line is two or more placeholders joined by separators, with at least one such line. */
+export const isFormatTemplate = (lines: readonly string[]): boolean => {
+  const filled = lines.filter((line) => line.trim() !== "");
+  return filled.length > 0 && filled.every(isTemplateLine);
+};

package/src/formula-brackets.ts

@@ -0,0 +1,36 @@
+import type { Span } from "./plugin.ts";
+
+// Round brackets that group an arithmetic formula (賃金 × (1 - 時間 ÷ 月平均)) rather than set off an aside in prose.
+
+const OPENING = new Set(["(", "（"]);
+const CLOSING = new Set([")", "）"]);
+/** Inside the brackets: a multiplication or division sign, or a plus, minus or equals sign with a space on each side. Unspaced, - and = are hyphens and labels (A-1, 2026-04). */
+const OPERATOR_INSIDE = /[×÷]|[ \u3000][+＋\-−－=＝][ \u3000]/u;
+/** Just before the opening bracket, past spaces: a multiplication or division sign, or a spaced sign. */
+const OPERATOR_BEFORE = /(?:[×÷]|[ \u3000][+＋\-−－=＝])[ \u3000]*$/u;
+/** Just after the closing bracket, past spaces. An asterisk is not a sign here: in prose it marks a note (*（注）). */
+const OPERATOR_AFTER = /^[ \u3000]*(?:[×÷]|[+＋\-−－=＝][ \u3000])/u;
+
+type Scan = { readonly open: number[]; readonly pairs: Span[] };
+
+const step = (scan: Scan, char: string, at: number): Scan => {
+  if (OPENING.has(char)) scan.open.push(at);
+  const start = CLOSING.has(char) ? scan.open.pop() : undefined;
+  if (start !== undefined) scan.pairs.push({ start, end: at + 1 });
+  return scan;
+};
+
+const isFormula = (text: string, pair: Span): boolean =>
+  OPERATOR_INSIDE.test(text.slice(pair.start + 1, pair.end - 1)) ||
+  OPERATOR_BEFORE.test(text.slice(0, pair.start)) ||
+  OPERATOR_AFTER.test(text.slice(pair.end));
+
+/**
+ * The bracket pairs in text that belong to a formula, each span covering both brackets. Full-width and half-width brackets
+ * pair with each other. A bracket left unclosed or closing nothing is not part of any pair. Positions count from 0 in text.
+ */
+export const formulaBracketSpans = (text: string): Span[] =>
+  text
+    .split("")
+    .reduce<Scan>(step, { open: [], pairs: [] })
+    .pairs.filter((pair) => isFormula(text, pair));

package/src/grade-api.ts

@@ -11,10 +11,13 @@ import { withStyle } from "./config/style.ts";
 import { withExtensions } from "./extension/load.ts";
 import { GENRES } from "./genre.ts";
 import { gradeItem, type GradeSetup } from "./grade/grade-item.ts";
-import { readItem } from "./grade/item.ts";
+import { expectProblems } from "./grade/expect-read.ts";
+import type { GradeExpect } from "./grade/expect.ts";
+import { readItem, type GradeItem } from "./grade/item.ts";
 import type { GradeResult } from "./grade/result.ts";
 import { parseRubric, type Rubric } from "./grade/rubric.ts";
 import { gradeSetup } from "./grade/setup.ts";
+import { taskNamesOf } from "./grade/task-rubric.ts";
 import { GRADE_TEXT } from "./grade/text.ts";
 import { compareVariantGroups, type VariantComparison } from "./grade/variants.ts";
 import { variantGroupsOf, type VariantInput } from "./grade/variants-input.ts";
@@ -36,6 +39,7 @@ export type {
   SupportedFact,
 } from "./grade/result.ts";
 export type { OutputSize } from "./grade/rates.ts";
+export type { GradeExpect } from "./grade/expect.ts";
 export type { AiLevelCounts, GradeAiScore } from "./grade/ai-score.ts";
 export { toScorer, type ChaffScore } from "./grade/scorer.ts";
 export type { Disagreement, VariantColumn, VariantComparison, VariantRates } from "./grade/variants.ts";
@@ -56,6 +60,10 @@ export type GradeOptions = {
   readonly genre?: string;
   /** The prompt, model or setting that produced the output, kept on the result for compareVariants(). */
   readonly variant?: string;
+  /** The rubric task to grade under: one of chaff.yaml's `grade.tasks`. The top-level rubric when left out. */
+  readonly task?: string;
+  /** Facts the output must state (`facts`) and must not (`absent`), each one fact as `chaff compare` reads it. */
+  readonly expect?: Partial<GradeExpect>;
   /** Run the experimental rules too, as --experimental does. chaff.yaml's `experimental` when left out. */
   readonly experimental?: boolean;
   /** chaff.yaml's path, or settings already read. Without it chaff's defaults apply and no file is read. */
@@ -125,36 +133,32 @@ const rubricOf = (config: Config): Rubric | undefined => {
  */
 const setups = new WeakMap<Config, Map<string, Promise<GradeSetup>>>();
 
-const setupFor = (config: Config, experimental: boolean, languages: readonly string[]): Promise<GradeSetup> => {
+const setupFor = (config: Config, rubric: Rubric | undefined, experimental: boolean, languages: readonly string[]): Promise<GradeSetup> => {
   const run = { experimental, genre: undefined };
   const own = setups.get(config) ?? new Map<string, Promise<GradeSetup>>();
   setups.set(config, own);
-  const key = `${String(experimental)}\n${languages.join(",")}`;
+  // The rubric is in the key: an item's task was checked against this rubric, so the setup must grade by the same one.
+  const key = `${String(experimental)}\n${languages.join(",")}\n${JSON.stringify(rubric) ?? ""}`;
   const known = own.get(key);
   if (known !== undefined) return known;
-  const made = remember(own, key, gradeSetup(config, run, languages, rubricOf(config)));
+  const made = remember(own, key, gradeSetup(config, run, languages, rubric));
   // A language package that failed to load may be installed before the next call: do not keep the failure.
   made.catch(() => own.delete(key));
   return made;
 };
 
 /** The setup, or GradeInputError when a language package cannot be loaded, as `chaff grade` ends with 2 then. */
-const loadedSetup = async (config: Config, experimental: boolean, languages: readonly string[]): Promise<GradeSetup> => {
+const loadedSetup = async (config: Config, rubric: Rubric | undefined, experimental: boolean, languages: readonly string[]): Promise<GradeSetup> => {
   try {
-    return await setupFor(config, experimental, languages);
+    return await setupFor(config, rubric, experimental, languages);
   } catch (error) {
     if (error instanceof GradeInputError) throw error;
     throw new GradeInputError([TEXT.cannotLoad(error instanceof Error ? error.message : String(error))]);
   }
 };
 
-/**
- * Grades one output (spec §29.6): its findings and rates, its facts against `reference`, its `citations` against
- * `sources`, and pass or fail by chaff.yaml's `grade:` or the default. Reads a file only when `config` is a path, and
- * never writes one. Throws GradeInputError for an input or a chaff.yaml `chaff grade` would refuse with exit 2.
- */
-export const grade = async (output: string, options: GradeOptions = {}): Promise<GradeResult> => {
-  const config = await configOf(options.config);
+/** The options read as one line of `chaff grade`'s input, refused as that line would be. `tasks`: those the rubric defines. */
+const itemOf = (output: string, options: GradeOptions, tasks: readonly string[]): GradeItem => {
   const raw = {
     id: options.id ?? "output",
     output,
@@ -165,11 +169,29 @@ export const grade = async (output: string, options: GradeOptions = {}): Promise
     language: options.language,
     genre: options.genre,
     variant: options.variant,
+    task: options.task,
+    expect: options.expect,
   };
-  const read = readItem(raw, { isLanguage: (language) => packageFor(language) !== undefined, genres: GENRES });
+  const read = readItem(raw, { isLanguage: (language) => packageFor(language) !== undefined, genres: GENRES, tasks });
   if ("problem" in read) throw new GradeInputError([TEXT.problem(read.problem)]);
-  const languages = read.item.language === undefined ? [] : [read.item.language];
-  return gradeItem(read.item, await loadedSetup(config, options.experimental ?? config.experimental, languages));
+  return read.item;
+};
+
+/**
+ * Grades one output (spec §29.6): its findings and rates, its facts against `reference`, its `citations` against
+ * `sources`, its `expect` facts, and pass or fail by chaff.yaml's `grade:` (its `task`'s rubric when named) or the
+ * default. Reads a file only when `config` is a path, and never writes one. Throws GradeInputError for an input or a
+ * chaff.yaml `chaff grade` would refuse with exit 2, an unknown `task` or an `expect` entry that is not one fact among them.
+ */
+export const grade = async (output: string, options: GradeOptions = {}): Promise<GradeResult> => {
+  const config = await configOf(options.config);
+  const rubric = rubricOf(config);
+  const item = itemOf(output, options, taskNamesOf(rubric));
+  const languages = item.language === undefined ? [] : [item.language];
+  const setup = await loadedSetup(config, rubric, options.experimental ?? config.experimental, languages);
+  const problems = await expectProblems(item, 0, setup);
+  if (problems.length > 0) throw new GradeInputError(problems.map((problem) => TEXT.problem(problem)));
+  return gradeItem(item, setup);
 };
 
 /**

package/src/heading-numbering.ts

@@ -41,16 +41,31 @@ const labelPattern = (label: NumberLabel): RegExp =>
 /** 見出しの頭の強調の印と空白。「**1. 概要**」も「1. 概要」と読む。 */
 const LEAD = /^[\s*_]+/u;
 
-/** 見出しの言葉から、番号の書き方を読む。番号を持つ語（第1章）を先に、字だけの形（1.）を後に見る。 */
-export const numberingStyleOf = (heading: string, labels: readonly NumberLabel[]): string => {
+type NumberMark = { readonly style: string; readonly mark: string };
+
+const markOf = (heading: string, labels: readonly NumberLabel[]): NumberMark => {
   const text = heading.replace(LEAD, "");
   const label = labels.find((candidate) => labelPattern(candidate).test(text));
-  if (label !== undefined) return `label:${label.word.toLowerCase()}`;
-  return SHAPES.find(([, shape]) => shape.test(text))?.[0] ?? UNNUMBERED;
+  if (label !== undefined) return { style: `label:${label.word.toLowerCase()}`, mark: labelPattern(label).exec(text)?.[0] ?? "" };
+  const shape = SHAPES.find(([, pattern]) => pattern.test(text));
+  return shape === undefined ? { style: UNNUMBERED, mark: "" } : { style: shape[0], mark: shape[1].exec(text)?.[0] ?? "" };
+};
+
+/** 見出しの言葉から、番号の書き方を読む。番号を持つ語（第1章）を先に、字だけの形（1.）を後に見る。 */
+export const numberingStyleOf = (heading: string, labels: readonly NumberLabel[]): string => markOf(heading, labels).style;
+
+/** 番号の中の数の一つ一つ（「7.1」の 7 と 1、「Chapter II」の II）。番号は印の最後に来るので、語の頭の大文字（Chapter の C）は最後にならない。 */
+const NUMBER_TOKEN = /[0-9０-９]+|[A-ZⅠ-Ⅻ①-⑳一二三四五六七八九十百]+/gu;
+const FIRST_NUMBERS: ReadonlySet<string> = new Set(["1", "１", "I", "Ⅰ", "A", "①", "一"]);
+
+/** 番号が並びの最初（1.、1.1、第1章、A.、①）か。最後の数が最初の数のときで、番号の無い見出しは並びを始めない。 */
+export const opensNumbering = (heading: string, labels: readonly NumberLabel[]): boolean => {
+  const last = markOf(heading, labels).mark.match(NUMBER_TOKEN)?.at(-1);
+  return last !== undefined && FIRST_NUMBERS.has(last);
 };
 
-/** 見出し 1 つ。depth は深さ（#の数）、style は番号の書き方、skipped は番号を付けない前後の見出し（目次・参考文献）。 */
-export type NumberedHeading = { readonly depth: number; readonly style: string; readonly skipped: boolean };
+/** 見出し 1 つ。depth は深さ（#の数）、style は番号の書き方、skipped は番号を付けない前後の見出し（目次・参考文献）、opens は番号が 1 から始まるか。 */
+export type NumberedHeading = { readonly depth: number; readonly style: string; readonly skipped: boolean; readonly opens: boolean };
 
 /** 親（直前の浅い見出し）と深さが同じ見出しの組。番号は兄弟の見出しのあいだで揃える。位置は渡した並びの添え字。 */
 export const siblingGroups = (headings: readonly NumberedHeading[]): number[][] => {
@@ -87,13 +102,25 @@ const minorityBy = (members: readonly number[], keyOf: (at: number) => string):
 const minoritiesOf = (split: Split | undefined, kind: NumberingMinority["kind"]): NumberingMinority[] =>
   split === undefined ? [] : split.minority.map((at) => ({ at, kind, majority: split.majority, count: split.count, example: split.example }));
 
+/** 番号の並びの最初の兄弟が 1 から始まるとき、その前の番号の無い兄弟（文書の題、「Applies to England」）は並びの外。番号付きの兄弟が二つ以上あるときだけ。 */
+const MIN_NUMBERED_RUN = 2;
+
+const leadingFrontMatter = (members: readonly number[], headings: readonly NumberedHeading[]): ReadonlySet<number> => {
+  const numbered = members.filter((at) => (headings[at]?.style ?? UNNUMBERED) !== UNNUMBERED);
+  const first = numbered[0];
+  if (first === undefined || numbered.length < MIN_NUMBERED_RUN || headings[first]?.opens !== true) return new Set();
+  return new Set(members.filter((at) => at < first));
+};
+
 /**
  * 兄弟の見出しのうち、少ないほうの書き方のもの。先に番号の有無を比べ（「1. 概要」「2. 手順」「まとめ」の「まとめ」）、
- * 番号の付いた見出しのあいだで書き方を比べる（「1.」「2.」「3）」の「3）」）。同じ数なら言わない（二つだけの兄弟は必ず同じ数か一つの書き方）。前後の見出し（目次・参考文献）は数えない。
+ * 番号の付いた見出しのあいだで書き方を比べる（「1.」「2.」「3）」の「3）」）。同じ数なら言わない（二つだけの兄弟は必ず同じ数か一つの書き方）。前後の見出し（目次・参考文献）と、1 から始まる番号の前の見出しは数えない。
  */
 export const numberingMinorities = (headings: readonly NumberedHeading[]): NumberingMinority[] =>
   siblingGroups(headings).flatMap((group) => {
-    const members = group.filter((at) => headings[at]?.skipped !== true);
+    const listed = group.filter((at) => headings[at]?.skipped !== true);
+    const front = leadingFrontMatter(listed, headings);
+    const members = listed.filter((at) => !front.has(at));
     const styleOf = (at: number): string => headings[at]?.style ?? UNNUMBERED;
     const numbered = members.filter((at) => styleOf(at) !== UNNUMBERED);
     return [

package/src/html/html-markdown.ts

@@ -37,6 +37,7 @@ import { withoutFootnoteMarks } from "./html-footnote-marks.ts";
 import { withoutHeadingSelfLinks } from "./html-heading-links.ts";
 import { withLostParagraphTagsRestored } from "./html-lost-tags.ts";
 import { withoutReaderOnlyText } from "./html-reader-only.ts";
+import { withoutSiteChrome } from "./html-site-chrome.ts";
 import { withRunInHeadingsRead } from "./html-run-in-headings.ts";
 import { withoutWidgets } from "./html-widgets.ts";
 import { withPreformattedRestored, withPreformattedStashed } from "./html-preformatted.ts";
@@ -465,7 +466,7 @@ export const htmlToMarkdown = (html: string): string => {
   const uncommented = withLostParagraphTagsRestored(withAttributeMarkupEscaped(html).replace(/<!--[\s\S]*?-->|<\?[\s\S]*?\?>/gu, ""));
   const preformatted = withPreformattedStashed(withTablesRead(DROPPED.reduce(withoutElement, withoutRubyText(uncommented))));
   const kept = withoutFootnoteMarks(
-    withoutHeadingSelfLinks(withoutWidgets(withoutButtons(withoutReaderOnlyText(withoutHiddenElements(mainContent(preformatted.html)))))),
+    withoutHeadingSelfLinks(withoutWidgets(withoutButtons(withoutReaderOnlyText(withoutHiddenElements(mainContent(withoutSiteChrome(preformatted.html))))))),
   ).replace(MARKUP_SPACE, " ");
   const content = withoutClosingLinks(
     withoutLinkGroups(withoutNavigation(withoutIconMenus(withoutSiteHeader(withoutNavigationLandmarks(withoutClosingAddress(kept)))))),

package/src/html/html-site-chrome.ts

@@ -0,0 +1,47 @@
+// The site's own chrome around a page, read from what the markup says a block is rather than from
+// any site's wording. A landmark role (banner, search, contentinfo), a <search> element, a <header> that belongs to the
+// page rather than to a section, and a block named by a convention CMSs share: a breadcrumb trail (breadcrumb, pankuzu,
+// topicpath), a search box, the header or footer block (id or class exactly "header" or "footer"), and the U.S.
+// government's ".gov" banner (usa-banner). A block holding the page's <h1> is never chrome. Pure; a regular-expression
+// reading, not a parser.
+import { ATTRIBUTES, elementRanges, isInside, withoutElementsOpening, withoutRanges, type ElementRange } from "./html-elements.ts";
+
+const CHROME_ROLES = new Set(["banner", "search", "contentinfo"]);
+
+// A name segment, so that "pankuzu_wrap", "foot_pankuzu" and "cse-search-box" match and "research" does not.
+const CHROME_NAME = /(?:^|[-_])(?:breadcrumbs?|pankuzu|topic-?path|search)(?:[-_\d]|$)/iu;
+
+const REGION_NAME = /^(?:header|footer|usa-banner)$/iu;
+
+const NAMED_OPENING = /<([a-z][a-z0-9-]*)\b[^>]*\s(?:class|id|role)\s*=/giu;
+
+const attributeValue = (openTag: string, name: string): string => {
+  const value = new RegExp(String.raw`^<[a-z][a-z0-9-]*${ATTRIBUTES}\s+${name}\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))`, "iu").exec(openTag);
+  return value?.[1] ?? value?.[2] ?? value?.[3] ?? "";
+};
+
+const tokens = (value: string): string[] => value.split(/\s+/u).filter((token) => token !== "");
+
+const holdsTitle = (range: ElementRange): boolean => /<h1\b/iu.test(range.inner);
+
+/** A role is a list of tokens and the first one counts, as for role="main". */
+const hasChromeRole = (openTag: string): boolean => CHROME_ROLES.has((tokens(attributeValue(openTag, "role"))[0] ?? "").toLowerCase());
+
+const hasChromeName = (openTag: string): boolean =>
+  [...tokens(attributeValue(openTag, "class")), ...tokens(attributeValue(openTag, "id"))].some((name) => CHROME_NAME.test(name) || REGION_NAME.test(name));
+
+/** A block the markup names or marks as the site's chrome, unless it holds the page's title. */
+export const isSiteChrome = (range: ElementRange): boolean => !holdsTitle(range) && (hasChromeRole(range.openTag) || hasChromeName(range.openTag));
+
+const SECTIONING = ["article", "section", "main", "aside", "nav"];
+
+/** A <header> inside an article or a section heads that part; one outside them is the page's banner. */
+const withoutPageHeaders = (html: string): string => {
+  const sections = SECTIONING.flatMap((tag) => elementRanges(html, tag));
+  const banners = elementRanges(html, "header").filter((header) => !holdsTitle(header) && !sections.some((section) => isInside(section, header)));
+  return withoutRanges(html, banners);
+};
+
+const withoutSearchElements = (html: string): string => withoutRanges(html, elementRanges(html, "search"));
+
+export const withoutSiteChrome = (html: string): string => withoutPageHeaders(withoutSearchElements(withoutElementsOpening(html, NAMED_OPENING, isSiteChrome)));

package/src/joined-view.ts

@@ -62,6 +62,7 @@ const sentenceInSource =
       text: text.slice(span.start, span.end),
       ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.map(tokenInSource(view)) }),
       ...(sentence.embeddedLanguage === undefined ? {} : { embeddedLanguage: sentence.embeddedLanguage }),
+      ...(sentence.listItem === undefined ? {} : { listItem: sentence.listItem }),
     };
   };
 

package/src/kanji-compound-slip.ts

@@ -0,0 +1,98 @@
+// A long kanji compound the document writes several times, and once or twice with one kanji changed (就職氷河期世代 ×5,
+// 就職永河期世代 ×2). Pure: the compounds come in with the words the analyser cut them into; which kanji may differ by
+// design (一, 第, 条) comes from a word list.
+
+/** One word of the analyser inside a compound, by kanji index: [start, end). `known` is false for a word not in its dictionary. */
+export type CompoundWord = {
+  readonly start: number;
+  readonly end: number;
+  readonly known: boolean;
+  /** The word reaches past the run (並びに after 受遺者); only its part inside is given. */
+  readonly crossesRun?: boolean;
+};
+
+export type CompoundUse = {
+  readonly compound: string;
+  readonly offset: number;
+  /** Absent where nothing was analysed. */
+  readonly words?: readonly CompoundWord[] | undefined;
+};
+
+type CompoundSlip = {
+  readonly written: string;
+  readonly usual: string;
+  readonly usualCount: number;
+  readonly offset: number;
+  readonly index: number;
+};
+
+const MIN_COMPOUND_LENGTH = 4;
+const MIN_USUAL_COUNT = 3;
+/** A slip copied once (a link and its twin) is still a slip; the usual form must then be written more than twice as often. */
+const MAX_SLIP_COUNT = 2;
+
+/** The one position where two compounds of the same length differ, or undefined when they differ in none or several. */
+export const singleDifference = (left: readonly string[], right: readonly string[]): number | undefined => {
+  if (left.length !== right.length) return undefined;
+  const differing = left.flatMap((char, index) => (char === right[index] ? [] : [index]));
+  return differing.length === 1 ? differing[0] : undefined;
+};
+
+/** The first and last kanji of a run are where a suffix (等, 者) or a conjunction written in kanji (及, 又) joins, not where a word is mistyped. */
+const isInside = (index: number, length: number): boolean => index > 0 && index < length - 1;
+
+const wordAt = (use: CompoundUse, index: number): CompoundWord | undefined => use.words?.find((word) => word.start <= index && index < word.end);
+
+const isLooseWithin = (word: CompoundWord | undefined, outer: CompoundWord): boolean =>
+  word !== undefined && word.crossesRun !== true && (!word.known || word.end - word.start === 1) && word.start >= outer.start && word.end <= outer.end;
+
+/**
+ * The analyser cannot read the changed word: where the usual form holds the kanji inside one word (氷河期), the slip
+ * falls apart there into single kanji or words it does not know (永 / 河 / 期). Returns the slip's kanji over that word.
+ */
+export const fallenWord = (slip: CompoundUse, usualUses: readonly CompoundUse[], index: number): string | undefined => {
+  const usualWord = usualUses.map((use) => wordAt(use, index)).find((word) => word !== undefined && word.end - word.start > 1);
+  if (usualWord === undefined) return undefined;
+  const positions = Array.from({ length: usualWord.end - usualWord.start }, (_, offset) => usualWord.start + offset);
+  const apart = positions.every((position) => isLooseWithin(wordAt(slip, position), usualWord));
+  return apart ? Array.from(slip.compound).slice(usualWord.start, usualWord.end).join("") : undefined;
+};
+
+/** The changed word written in another kanji run (質権 in 質権者は beside 当該質権者): a word the document knows. */
+const isWrittenElsewhere = (word: string, slip: string, uses: readonly CompoundUse[]): boolean =>
+  uses.some((use) => use.compound !== slip && use.compound.includes(word));
+
+type SlipContext = { readonly ignored: ReadonlySet<string>; readonly uses: readonly CompoundUse[] };
+
+type Usual = { readonly compound: string; readonly count: number; readonly uses: readonly CompoundUse[] };
+
+const countsOf = (uses: readonly CompoundUse[]): ReadonlyMap<string, number> =>
+  uses.reduce((counts, use) => counts.set(use.compound, (counts.get(use.compound) ?? 0) + 1), new Map<string, number>());
+
+const usualsOf = (uses: readonly CompoundUse[], counts: ReadonlyMap<string, number>): Usual[] =>
+  [...counts]
+    .filter(([compound, count]) => count >= MIN_USUAL_COUNT && Array.from(compound).length >= MIN_COMPOUND_LENGTH)
+    .map(([compound, count]) => ({ compound, count, uses: uses.filter((use) => use.compound === compound) }));
+
+const slipAgainst = (use: CompoundUse, count: number, usual: Usual, context: SlipContext): CompoundSlip | undefined => {
+  const [written, other] = [Array.from(use.compound), Array.from(usual.compound)];
+  const index = usual.count > count * 2 ? singleDifference(written, other) : undefined;
+  if (index === undefined || !isInside(index, written.length)) return undefined;
+  if (context.ignored.has(written[index] ?? "") || context.ignored.has(other[index] ?? "")) return undefined;
+  const fallen = fallenWord(use, usual.uses, index);
+  if (fallen === undefined || isWrittenElsewhere(fallen, use.compound, context.uses)) return undefined;
+  return { written: use.compound, usual: usual.compound, usualCount: usual.count, offset: use.offset, index };
+};
+
+/** Each compound written once or twice that differs in one kanji from a compound of the same length written at least three times. */
+export const compoundSlipsIn = (uses: readonly CompoundUse[], ignored: ReadonlySet<string>): CompoundSlip[] => {
+  const counts = countsOf(uses);
+  const usuals = usualsOf(uses, counts);
+  if (usuals.length === 0) return [];
+  return uses.flatMap((use) => {
+    const count = counts.get(use.compound) ?? 0;
+    if (count > MAX_SLIP_COUNT || Array.from(use.compound).length < MIN_COMPOUND_LENGTH) return [];
+    const slips = usuals.flatMap((usual) => slipAgainst(use, count, usual, { ignored, uses }) ?? []);
+    return slips.length === 1 ? slips : [];
+  });
+};

package/src/latin-company-form.ts

@@ -0,0 +1,38 @@
+import type { Span } from "./plugin.ts";
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const LATIN_LETTER = /[A-Za-z]/u;
+const SPACE = "[\\s\\u3000]";
+
+/**
+ * 形は名前の後ろに立つ。前は大文字か数字で始まる名前の語か括弧で、あいだは空白か「,」だけ（AOBA INC.、AOBA,INC.、
+ * (THAILAND) CO.,LTD.）。語の中（Zinc の inc）、略語の中（U.S.A. の S.A.）、名前の無い所（the LLC）の同じ字は形ではない。
+ */
+const NAME_WORD = "(?<![A-Za-zＡ-Ｚａ-ｚ])[A-ZＡ-Ｚ0-9０-９][A-Za-zＡ-Ｚａ-ｚ0-9０-９&＆]*";
+const BEFORE = `(?<=${NAME_WORD}(?:${SPACE}|[,，]${SPACE}?)|[)）]${SPACE}?)`;
+const AFTER = "(?![A-Za-zＡ-Ｚａ-ｚ0-9０-９&＆])";
+
+const escaped = (char: string): string => char.replace(/[.*+?^${}()|[\]\\]/u, "\\$&");
+
+const widths = (char: string): string[] => [char, String.fromCodePoint((char.codePointAt(0) ?? 0) + FULLWIDTH_OFFSET)];
+
+/** 一字の形。英字は大文字・小文字と全角・半角のどれでも、点と「,」は全角・半角のどちらでも合う。空白は無くても合う。 */
+const charPattern = (char: string): string => {
+  if (char === " ") return `${SPACE}?`;
+  if (LATIN_LETTER.test(char)) return `[${[char.toUpperCase(), char.toLowerCase()].flatMap(widths).join("")}]`;
+  return /[.,]/u.test(char) ? `[${widths(char).map(escaped).join("")}]` : escaped(char);
+};
+
+/** 形は点まで書いたとおりに照らす。点の無い LTD（the LTD fund）は形と読まない。英字で終わる形（LLC）は語の終わりで閉じる。 */
+const formPattern = (form: string): string => [...form].map(charPattern).join("") + (LATIN_LETTER.test(form.slice(-1)) ? AFTER : "");
+
+/** 形の語彙表を、一つの正規表現にする。長い形を先に試す。名前の語は大文字で始まるので、大文字・小文字は形の側だけで問わない。 */
+export const latinCompanyFormRegExp = (forms: readonly string[]): RegExp | undefined => {
+  if (forms.length === 0) return undefined;
+  const longestFirst = [...forms].sort((a, b) => b.length - a.length);
+  return new RegExp(`${BEFORE}(?:${longestFirst.map(formPattern).join("|")})`, "gu");
+};
+
+/** text の中の、英字の会社の名前の後ろに立つ形（CO.，LTD.、Inc.）の位置。大文字・小文字と全角・半角を問わない。 */
+export const latinCompanyFormSpans = (text: string, pattern: RegExp | undefined): Span[] =>
+  pattern === undefined ? [] : [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/latin-word-boundary.ts

@@ -0,0 +1,46 @@
+import type { Boundary } from "./orthography.ts";
+import type { Span, Token } from "./plugin.ts";
+
+// 英字の語の側で決まる、空け方の好みでない境目。pure: 語は語彙表から受け取る。
+
+/** 英字の語を作る字。vs. の点も語の一部。 */
+const LATIN_WORD_CHAR = /[A-Za-z.]/u;
+const LATIN_WORD_AFTER = /^[A-Za-z.]+/u;
+const JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー]/u;
+
+/** 境目の英字の側の語の範囲（「名前 or 任意」の or）。 */
+const latinWordAt = (text: string, boundary: Boundary): Span => {
+  if (LATIN_WORD_CHAR.test(text[boundary.offset - 1] ?? "")) {
+    const reversed = Array.from(text.slice(0, boundary.offset)).toReversed().join("");
+    return { start: boundary.offset - (LATIN_WORD_AFTER.exec(reversed)?.[0].length ?? 0), end: boundary.offset };
+  }
+  const start = boundary.offset + (boundary.spaced ? 1 : 0);
+  return { start, end: start + (LATIN_WORD_AFTER.exec(text.slice(start))?.[0].length ?? 0) };
+};
+
+/** 語の前後が空白一つで、その外がどちらも日本語の字。 */
+const standsBetweenJapanese = (text: string, word: Span): boolean =>
+  text[word.start - 1] === " " && text[word.end] === " " && JAPANESE.test(text[word.start - 2] ?? "") && JAPANESE.test(text[word.end + 1] ?? "");
+
+/**
+ * 日本語の句と句をつなぐ英語の語（「名前 or メッセージ」「甲案 vs. 乙案」の or、vs.）の前後の空白。or を詰めて書くことは無く、
+ * 語を区切る空白で、日本語と英字のあいだの空け方の票ではない。片側が英字の語（A or 任意、名前 or API）なら数える。
+ * joiners は語彙表 latin-joiner の語（小文字）。
+ */
+export const isJoinerSpace = (text: string, boundary: Boundary, joiners: ReadonlySet<string>): boolean => {
+  if (boundary.kind !== "letter" || !boundary.spaced) return false;
+  const word = latinWordAt(text, boundary);
+  return joiners.has(text.slice(word.start, word.end).toLowerCase()) && standsBetweenJapanese(text, word);
+};
+
+/**
+ * 英字の語に付けて一つの語にする日本語の接尾の語（PDF版、IT化、Apple製）の前の境目。空けて書くことはほとんど無く、
+ * 詰めたのは空け方の好みではない。語の頭の字が同じでも別の語（製品、型番）なら数える。suffixes は語彙表 latin-bound-suffix の語。
+ * tokens は文書全体の座標で、base は text の先頭の位置。
+ */
+export const isBoundSuffix = (text: string, boundary: Boundary, tokens: readonly Token[] | undefined, base: number, suffixes: ReadonlySet<string>): boolean => {
+  if (tokens === undefined || boundary.kind !== "letter" || !LATIN_WORD_CHAR.test(text[boundary.offset - 1] ?? "")) return false;
+  const start = base + boundary.offset + (boundary.spaced ? 1 : 0);
+  const suffix = tokens.find((token) => token.span.start === start);
+  return suffix !== undefined && suffixes.has(suffix.surface);
+};

package/src/lexicon-genres.ts

@@ -1,7 +1,7 @@
 import type { Lexicon } from "./plugin.ts";
 
 /** A genre is in a target when it is the target or one of its genres (legal/contract is in legal). */
-const isIn = (genre: string, target: string): boolean => genre === target || genre.startsWith(`${target}/`);
+export const isIn = (genre: string, target: string): boolean => genre === target || genre.startsWith(`${target}/`);
 
 /**
  * The entries of a word list that hold for the document's genre: an entry without genres holds everywhere, one with genres only

package/src/link-shape.ts

@@ -60,3 +60,22 @@ export const isFileNameAlt = (alt: string, prefixes: readonly string[]): boolean
   const lowered = written.toLowerCase();
   return prefixes.some((prefix) => lowered.startsWith(prefix.toLowerCase()) && COUNTER.test(written.slice(prefix.length)));
 };
+
+/** A list item's marker before a line's text (`- `, `* `, `1. `). */
+const LIST_MARKER = /^\s*(?:[-*+]|\d{1,3}[.)])\s+/u;
+/**
+ * A field's label: a few words in bold (`**Licence text**`, a colon after it or not), or ending in a colon (`Website:`).
+ * Sentence punctuation or a comma in it makes it prose (`For example, visit:`).
+ */
+const BOLD_LABEL = /^(?:\*\*[^*\n.!?。！？,，、:：]{1,40}\*\*|__[^_\n.!?。！？,，、:：]{1,40}__)\s*[:：]?$/u;
+const COLON_LABEL = /^[^.!?。！？,，、:：]{1,40}[:：]$/u;
+
+/**
+ * Whether a URL is the value of a field (`**Licence text** https://…`, `Website: https://…`): on its line only a label comes
+ * before it and nothing after. There the address is the content, as in a table cell, so writing it bare is right.
+ */
+export const isFieldValueUrl = (lineBefore: string, lineAfter: string): boolean => {
+  if (lineAfter.trim() !== "") return false;
+  const label = lineBefore.replace(LIST_MARKER, "").trim();
+  return BOLD_LABEL.test(label) || COLON_LABEL.test(label);
+};