chaffjs 0.27.1 → 0.29.0

package/src/html/html-reader-only.ts

@@ -0,0 +1,82 @@
+// Text a page writes for a screen reader alone, which a sighted reader never sees: an element whose class follows a
+// visually-hidden convention, and the anchor a skip link moves focus to. Pure; a regular-expression reading.
+import {
+  ATTRIBUTES,
+  HEADING_TAGS,
+  headingRanges,
+  isInside,
+  plainText,
+  withoutElementsOpening,
+  withoutElementsWhere,
+  type ElementRange,
+} from "./html-elements.ts";
+
+// The class names that frameworks and style guides give text written for a screen reader alone (sr-only,
+// visually-hidden, govuk-visually-hidden, screen-reader-text), never negated (not-sr-only shows it); "hidden" only as
+// a whole name (not hidden-xs).
+const READER_ONLY_CLASS = /^(?:(?!not-)[a-z0-9]+-)*(?:sr-only|visually-?hidden|screen-reader-text|element-invisible)$/iu;
+
+const CLASS_OPENING = /<([a-z][a-z0-9-]*)\b[^>]*\sclass\s*=/giu;
+
+const CLASS_VALUE = new RegExp(String.raw`^<[a-z][a-z0-9-]*${ATTRIBUTES}\s+class\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))`, "iu");
+
+/** A variant (md:block, md:not-sr-only) shows the element on some screens or states, so it is not hidden from sight. */
+const isReaderOnlyClass = (range: ElementRange): boolean => {
+  const value = CLASS_VALUE.exec(range.openTag);
+  const names = (value?.[1] ?? value?.[2] ?? value?.[3] ?? "").split(/\s+/u);
+  if (names.some((name) => name.includes(":"))) return false;
+  return names.some((name) => READER_ONLY_CLASS.test(name)) || names.includes("hidden");
+};
+
+/** An anchor with no href that only a script can focus: where a skip link moves the reader ("ここから本文です。"). */
+const isFocusTarget = (range: ElementRange): boolean =>
+  !/\shref\s*=/iu.test(range.openTag) && /\stabindex\s*=\s*(?:"\s*-1\s*"|'\s*-1\s*'|-1(?=[\s/>]))/iu.test(range.openTag);
+
+const LINE_TAGS = [
+  "p",
+  "div",
+  "li",
+  "dt",
+  "dd",
+  "td",
+  "th",
+  ...HEADING_TAGS,
+  "section",
+  "article",
+  "header",
+  "footer",
+  "main",
+  "body",
+  "blockquote",
+  "ul",
+  "ol",
+  "dl",
+  "table",
+  "tr",
+];
+
+const LINE_BOUNDARY = new RegExp(String.raw`<\/?(?:${LINE_TAGS.join("|")})\b[^<>]*>|<br\b[^<>]*>`, "giu");
+
+/** Text between the anchor and the block's edge on each side: what shares a line with it. */
+const lineAround = (html: string, range: ElementRange): readonly [string, string] => {
+  const before = html.slice(0, range.start);
+  const lineStart = [...before.matchAll(LINE_BOUNDARY)].at(-1);
+  const after = html.slice(range.end);
+  const lineEnd = new RegExp(LINE_BOUNDARY.source, "iu").exec(after)?.index ?? after.length;
+  return [lineStart === undefined ? before : before.slice(lineStart.index + lineStart[0].length), after.slice(0, lineEnd)];
+};
+
+/** No other text on its line: the anchor is a block of its own, not a word in a sentence. */
+const standsAlone = (html: string, range: ElementRange): boolean => lineAround(html, range).every((beside) => plainText(beside) === "");
+
+/**
+ * Text the page writes for a screen reader and does not show. A focus target counts only standing alone outside a
+ * heading: inside a heading it is the heading's title, inside a sentence a word of it.
+ */
+export const withoutReaderOnlyText = (html: string): string => {
+  const shown = withoutElementsOpening(html, CLASS_OPENING, isReaderOnlyClass);
+  const headings = headingRanges(shown);
+  const isReaderTarget = (anchor: ElementRange): boolean =>
+    isFocusTarget(anchor) && standsAlone(shown, anchor) && !headings.some((heading) => isInside(heading, anchor));
+  return withoutElementsWhere(shown, "a", isReaderTarget);
+};

package/src/html/html-run-in-headings.ts

@@ -0,0 +1,43 @@
+// A section title drawn as a bold first line of its paragraph: <p><strong>Conclusion</strong><br />In closing, …</p>.
+// Read as text the title runs into the paragraph as one line. The bold run becomes a heading one level below the
+// heading before it (h2 when none), and the rest stays the paragraph. Only a bold run that opens the paragraph, holds
+// plain text, is short, does not end as a sentence or a label (".", ":") and has a sentence (or a lead-in ending in a
+// colon) after its line break is taken for a title; a name over its role ("Jane Roe<br>Secretary") is a signature. Pure.
+import { hasSentence, plainText } from "./html-elements.ts";
+
+const MAX_TITLE_LENGTH = 100;
+const DEEPEST_LEVEL = 6;
+const TOP_LEVEL = 1;
+
+// A paragraph's start, a bold run and a line break: the paragraph's text follows up to its end tag.
+const OPENING = /<p\b([^>]*)>\s*<(strong|b)\b[^>]*>([^<]*)<\/\2\s*>\s*<br\b[^>]*>/giu;
+
+/** The paragraph's text after from, up to its end tag; undefined when another paragraph opens first or none closes. */
+const restOfParagraph = (html: string, from: number): string | undefined => {
+  const next = /<(\/?)p\b/iu.exec(html.slice(from));
+  return next?.[1] === "/" ? html.slice(from, from + next.index) : undefined;
+};
+
+// A sentence's end, a label's colon, or a clause's comma or semicolon: the bold run is part of the text, not a title.
+const ENDS_AS_TEXT = /[.!?:;,。！？：；、]$/u;
+
+/** A sentence, or a lead-in to a list ("… with the same:"): what a section holds, unlike a role under a name. */
+const isProse = (html: string): boolean => hasSentence(html) || /[:：]$/u.test(plainText(html));
+
+const isTitle = (bold: string, rest: string | undefined): boolean => {
+  const title = bold.trim();
+  return title !== "" && title.length <= MAX_TITLE_LENGTH && !ENDS_AS_TEXT.test(title) && rest !== undefined && isProse(rest);
+};
+
+/** The level of the last heading opening before at; 1 when there is none, as if under the page's title. */
+const levelBefore = (html: string, at: number): number => {
+  const headings = [...html.slice(0, at).matchAll(/<h([1-6])\b/giu)];
+  return Number(headings.at(-1)?.[1] ?? TOP_LEVEL);
+};
+
+export const withRunInHeadingsRead = (html: string): string =>
+  html.replace(OPENING, (opening: string, attributes: string, _tag: string, bold: string, at: number) => {
+    if (!isTitle(bold, restOfParagraph(html, at + opening.length))) return opening;
+    const level = String(Math.min(levelBefore(html, at) + 1, DEEPEST_LEVEL));
+    return `<h${level}>${bold.trim()}</h${level}><p${attributes}>`;
+  });

package/src/html/html-tables.ts

@@ -0,0 +1,76 @@
+// Tables as the HTML converter reads them. A table whose rows are sentences (a glossary of terms and what they mean,
+// a list of routes and how each one works) keeps each cell as a block of its own, so its sentences are read as prose;
+// its header rows go. Any other table (figures, a grid of links) goes whole, as before. Nested tables are read from
+// the inside out. Pure; a regular-expression reading, not a parser.
+import { plainText, untilStable } from "./html-elements.ts";
+
+type Cell = { readonly header: boolean; readonly html: string };
+type Row = readonly Cell[];
+
+const INNERMOST_TABLE = /<table\b[^>]*>((?:(?!<table\b)[\s\S])*?)<\/table\s*>/giu;
+
+// A row and a cell may leave out their closing tags: each ends where the next one opens.
+const ROW_OPENING = /<tr\b[^>]*>/iu;
+const ROW_END = /<\/(?:tr|thead|tbody|tfoot)\s*>[\s\S]*$/iu;
+const CELL_OPENING = /<(t[dh])\b[^>]*>/giu;
+const CELL_END = /<\/t[dh]\s*>[\s\S]*$/iu;
+
+const cellsOf = (row: string): Row => {
+  const openings = [...row.matchAll(CELL_OPENING)];
+  return openings.map((opening, index) => {
+    const end = openings[index + 1]?.index ?? row.length;
+    const html = row.slice(opening.index + opening[0].length, end).replace(CELL_END, "");
+    return { header: opening[1]?.toLowerCase() === "th", html };
+  });
+};
+
+const rowsOf = (table: string): Row[] =>
+  table
+    .split(ROW_OPENING)
+    .slice(1)
+    .map((row) => cellsOf(row.replace(ROW_END, "")));
+
+const hasText = (cell: Cell): boolean => plainText(cell.html) !== "";
+
+// A cell ends a sentence with its last mark. A point inside it ("H.Con.Res. 218") or after a short capitalised word
+// or a letter after a point ("Inc.", "U.S.") is an abbreviation.
+const ENDS_SENTENCE = /(?:[。．！？!?]|(?<!\b[A-Z][A-Za-z]{0,3}|\.[A-Za-z])\.)[)\]"'”’」』）]*$/u;
+
+const holdsSentence = (cell: Cell): boolean => ENDS_SENTENCE.test(plainText(cell.html));
+
+// A cell that opens with a number and holds no word of the Latin alphabet: a row number ("1", "2."), a figure or a
+// range ("0.3 以上 1.6未満", "１未満"), a section ("302(c)"). "401(k) plan" and "24/7 desk" are names.
+const isNumberLabel = (text: string): boolean => /^\p{Nd}/u.test(text) && !/[A-Za-z]{2,}/u.test(text);
+
+/**
+ * A cell kept as a block: one with a sentence, or a label in words. A number label is read by no prose rule, and alone
+ * on a line it would read as a section number.
+ */
+const isKept = (cell: Cell): boolean => holdsSentence(cell) || (hasText(cell) && !isNumberLabel(plainText(cell.html)));
+
+/** A row of nothing but header cells labels the columns. */
+const isHeaderRow = (row: Row): boolean => row.length > 0 && row.every((cell) => cell.header);
+
+/** At least half of the rows with text in them, header rows aside, hold a sentence. */
+const isProse = (rows: readonly Row[]): boolean => {
+  const written = rows.filter((row) => !isHeaderRow(row) && row.some(hasText));
+  const sentences = written.filter((row) => row.some(holdsSentence)).length;
+  return sentences > 0 && sentences * 2 >= written.length;
+};
+
+const CAPTION = /<caption\b[^>]*>([\s\S]*?)<\/caption\s*>/iu;
+
+/** Each cell with text as a block, the caption first. */
+const asBlocks = (table: string, rows: readonly Row[]): string => {
+  const caption = CAPTION.exec(table)?.[1];
+  const cells = rows.filter((row) => !isHeaderRow(row)).flatMap((row) => row.filter(isKept).map((cell) => cell.html));
+  return ["<div>", ...[caption ?? "", ...cells].filter((html) => html !== "").map((html) => `<div>${html}</div>`), "</div>"].join("");
+};
+
+const readTable = (_whole: string, inside: string): string => {
+  const rows = rowsOf(inside);
+  return isProse(rows) ? asBlocks(inside, rows) : " ";
+};
+
+/** Every table read from the inside out: a table of sentences as blocks, any other table replaced by a space. */
+export const withTablesRead = (html: string): string => untilStable(html, (text) => text.replace(INNERMOST_TABLE, readTable));

package/src/html/html-widgets.ts

@@ -0,0 +1,114 @@
+// Parts of a page that are controls rather than the document: a tooltip, a media player with its buttons, a block a
+// script runs when clicked, a bar of previous and next links between arrows, and text marked never to be spoken.
+// Each is told by its structure (a role, an <audio> or <video>, an event handler, the arrows), never by a site's class
+// names. Pure; a regular-expression reading.
+import {
+  ANY_LINK,
+  ATTRIBUTES,
+  elementRanges,
+  fileExtension,
+  hasNoWords,
+  hasSentence,
+  isFileLink,
+  plainText,
+  withoutElementsOpening,
+  withoutRanges,
+  type ElementRange,
+} from "./html-elements.ts";
+
+/** Every element whose opening tag carries attribute (name and value as a pattern), matched to its own closing tag. */
+const withoutElementsWithAttribute = (html: string, attribute: string): string => {
+  const opening = new RegExp(String.raw`<([a-z][a-z0-9-]*)${ATTRIBUTES}\s+${attribute}`, "giu");
+  const marked = new RegExp(String.raw`^<[a-z][a-z0-9-]*${ATTRIBUTES}\s+${attribute}`, "iu");
+  return withoutElementsOpening(html, opening, (range) => marked.test(range.openTag));
+};
+
+// A role is a list of tokens and the first one counts, as for role="main".
+const TOOLTIP_ROLE = String.raw`role\s*=\s*(?:"\s*tooltip(?:\s[^"]*)?"|'\s*tooltip(?:\s[^']*)?'|tooltip(?=[\s/>]))`;
+
+// speak: none in a style says the text is not to be read out: data for scripts, such as an id beside a title.
+const UNSPOKEN_STYLE = String.raw`style\s*=\s*(?:"[^"]*\bspeak\s*:\s*none\b[^"]*"|'[^']*\bspeak\s*:\s*none\b[^']*')`;
+
+/** A tooltip ("The code has been copied to your clipboard.") shows beside a control, and unspoken text is not read. */
+const withoutTooltipsAndUnspoken = (html: string): string => withoutElementsWithAttribute(withoutElementsWithAttribute(html, TOOLTIP_ROLE), UNSPOKEN_STYLE);
+
+const MEDIA_ELEMENT = /<(audio|video)\b[^>]*>[\s\S]*?<\/\1\s*>/giu;
+
+const PLAYER_BLOCKS = ["div", "section", "figure"];
+
+// A caption is the document's even when it is not a sentence ("Interview with the mayor"), so its block is no player.
+const holdsMedia = (range: ElementRange): boolean => /<(?:audio|video)\b/iu.test(range.inner) && !/<figcaption\b/iu.test(range.inner);
+
+/** The text around the media, without the words a browser shows only when it cannot play it. */
+const hasSentenceBesideMedia = (range: ElementRange): boolean => hasSentence(range.inner.replace(MEDIA_ELEMENT, " "));
+
+const MEDIA_EXTENSION = /^(?:mp3|m4a|aac|wav|ogg|oga|opus|mp4|m4v|webm|mov)$/iu;
+
+/** A link to a file other than the media itself (a transcript in PDF, an address) is the document's. */
+const isDocumentFile = (link: string): boolean => isFileLink(link) && !MEDIA_EXTENSION.test(fileExtension(link) ?? "");
+
+const isPlayer = (range: ElementRange): boolean =>
+  holdsMedia(range) && !hasSentenceBesideMedia(range) && ![...range.inner.matchAll(ANY_LINK)].some((link) => isDocumentFile(link[0]));
+
+/**
+ * A block holding an <audio> or <video> and not a sentence is its player: the controls, the timer, "Embed", "share",
+ * "Direct link" to the media's own file. The outermost such block goes; a block with a sentence, a caption or a link
+ * to another file stays.
+ */
+const withoutMediaPlayers = (html: string): string => {
+  const players = PLAYER_BLOCKS.flatMap((tag) => elementRanges(html, tag)).filter(isPlayer);
+  return withoutRanges(
+    html,
+    players.toSorted((left, right) => left.start - right.start || right.end - left.end),
+  );
+};
+
+const EVENT_HANDLER = String.raw`on[a-z]+\s*=`;
+
+const CONTROL_OPENING = new RegExp(String.raw`<(div|p|span|li)${ATTRIBUTES}\s+${EVENT_HANDLER}`, "giu");
+
+/** Links and nothing else, but no link that wraps blocks. */
+const isOnlyPlainLinks = (inner: string): boolean => {
+  const links = [...inner.matchAll(ANY_LINK)].map((link) => link[0]);
+  return links.length > 0 && !links.some((link) => /<(?:div|p|h[1-6]|ul|ol)\b/iu.test(link)) && hasNoWords(plainText(inner.replace(ANY_LINK, " ")));
+};
+
+/**
+ * A block that runs a script when clicked (onclick) and holds only a link ("Start Quiz") is a button drawn as a link.
+ * A link with a handler of its own, inside a sentence, stays: it is only counted when followed.
+ */
+const isScriptedControl = (range: ElementRange): boolean =>
+  new RegExp(String.raw`^<[a-z]+${ATTRIBUTES}\s+${EVENT_HANDLER}`, "iu").test(range.openTag) && isOnlyPlainLinks(range.inner);
+
+const withoutScriptedControls = (html: string): string => withoutElementsOpening(html, CONTROL_OPENING, isScriptedControl);
+
+const BACK_ARROW = "[←‹«◀◁]";
+const FORWARD_ARROW = "[→›»▶▷]";
+const PAGING_TEXT = new RegExp(`^${BACK_ARROW}.*${FORWARD_ARROW}$`, "u");
+const MIN_PAGING_LINKS = 2;
+
+const PAGING_BLOCKS = ["div", "section", "p", "td"];
+
+/**
+ * Opens with a back arrow and closes with a forward one around two or more links to pages (never a file), with no sentence beside them: "←
+ * Previous | Title | Next →". Link text is not looked at, since a name's initial ("John P.") is not a sentence.
+ */
+const isPagingBar = (range: ElementRange): boolean => {
+  const links = [...range.inner.matchAll(ANY_LINK)].map((link) => link[0]);
+  return (
+    PAGING_TEXT.test(plainText(range.inner)) && links.length >= MIN_PAGING_LINKS && !links.some(isFileLink) && !hasSentence(range.inner.replace(ANY_LINK, " "))
+  );
+};
+
+/** The innermost blocks that are a bar of previous and next links, as a work's header draws them over each chapter. */
+const withoutPagingBars = (html: string): string => {
+  const bars = PAGING_BLOCKS.flatMap((tag) => elementRanges(html, tag)).filter(isPagingBar);
+  const innermost = bars.filter((outer) => !bars.some((inner) => inner !== outer && outer.start <= inner.start && inner.end <= outer.end));
+  return withoutRanges(
+    html,
+    innermost.toSorted((left, right) => left.start - right.start),
+  );
+};
+
+/** Controls and their text: tooltips, unspoken data, media players, scripted link buttons and paging bars. */
+export const withoutWidgets = (html: string): string => withoutPagingBars(withoutScriptedControls(withoutMediaPlayers(withoutTooltipsAndUnspoken(html))));

package/src/html/markup-text.ts

@@ -0,0 +1,35 @@
+// What the wikitext and HTML converters share: character references turned back into characters, and the blank
+// lines and trailing spaces a converter leaves behind tidied away. Pure.
+import { characterEntities } from "character-entities";
+
+// A named space ( ,  ) is read as a plain space, like the spacing between the page's other words.
+const isSpace = (value: string): boolean => /^\p{Zs}+$/u.test(value);
+
+/** A name of the HTML standard, matched as written: "Ø" is Ø and "ø" is ø. */
+const decodeName = (name: string, whole: string): string => {
+  const value = Object.hasOwn(characterEntities, name) ? characterEntities[name] : undefined;
+  if (value === undefined) return whole;
+  return isSpace(value) ? " " : value;
+};
+
+const fromCodePoint = (code: number, whole: string): string => (Number.isInteger(code) && code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : whole);
+
+const decodeOne = (whole: string, name: string): string => {
+  if (name.startsWith("#x") || name.startsWith("#X")) return fromCodePoint(Number.parseInt(name.slice(2), 16), whole);
+  if (name.startsWith("#")) return fromCodePoint(Number.parseInt(name.slice(1), 10), whole);
+  return decodeName(name, whole);
+};
+
+/** In one pass, so "&amp;lt;" is "&lt;" and not "<". An unknown name is left as written. */
+export const decodeEntities = (text: string): string =>
+  text.replace(/&(#x[0-9a-f]+|#\d+|[a-z][a-z0-9]*);/giu, (whole: string, name: string) => decodeOne(whole, name));
+
+/** Trailing spaces removed, runs of blank lines made one, and a single newline at the end. */
+export const tidyLines = (lines: readonly string[]): string => {
+  const text = lines
+    .map((line) => line.trimEnd())
+    .join("\n")
+    .replace(/\n{3,}/gu, "\n\n")
+    .trim();
+  return text === "" ? "" : `${text}\n`;
+};

package/src/html/page-document.ts

@@ -0,0 +1,22 @@
+// A fetched page as a document chaff reads: HTML turned into Markdown (headings become addresses), Markdown and plain
+// text as they are. Anything else (a PDF, JSON, an image) is not text a quotation can be found in. Pure.
+import { htmlToMarkdown } from "./html-markdown.ts";
+
+/** The document a page reads as: the name that says how to read it (.md or .txt), and its text. */
+export type PageDocument = { readonly path: string; readonly text: string } | { readonly unsupported: string };
+
+const mediaTypeOf = (contentType: string | null): string => (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+
+/** A body sent with no Content-Type is HTML when it opens like markup. */
+const LOOKS_LIKE_HTML = /^\s*(?:<!doctype html|<html[\s>]|<head[\s>]|<body[\s>])/iu;
+
+const HTML_TYPES: ReadonlySet<string> = new Set(["text/html", "application/xhtml+xml"]);
+const MARKDOWN_TYPES: ReadonlySet<string> = new Set(["text/markdown", "text/x-markdown"]);
+
+export const pageDocument = (contentType: string | null, body: string): PageDocument => {
+  const type = mediaTypeOf(contentType);
+  if (HTML_TYPES.has(type) || (type === "" && LOOKS_LIKE_HTML.test(body))) return { path: "page.md", text: htmlToMarkdown(body) };
+  if (MARKDOWN_TYPES.has(type)) return { path: "page.md", text: body };
+  if (type === "" || type.startsWith("text/")) return { path: "page.txt", text: body };
+  return { unsupported: type };
+};

package/src/inline-count.ts

@@ -0,0 +1,146 @@
+import { escapeRegExp } from "./orthography.ts";
+import { alternation, valueOf, type CountMismatch, type CountWords } from "./announced-count.ts";
+
+/**
+ * 一行に並べた名前の予告（出席者（6名）：田中、鈴木、佐藤 / Attendees (6): Tanaka, Suzuki）。ラベルの後ろの括弧の数と、
+ * コロンの後ろに区切って並べた名前の数を比べる。区切りが決まらない並び（名前をつなぐ語がある、括弧が閉じていない、文が続く）と、
+ * 閉じていない並び（ほか、etc.）は数えない。言語の知識（区切り、つなぐ語、閉じていないことを言う語）は語彙表から受け取る。
+ */
+export type MemberWords = {
+  /** 名前の区切り。、 , */
+  readonly separators: readonly string[];
+  /** 名前をつなぐ語。と、and。 */
+  readonly joiners: readonly string[];
+  /** 並びが閉じていないことを言う語。ほか、etc。 */
+  readonly open: readonly string[];
+};
+
+const MAX_LABEL_CHARS = 30;
+const MAX_MEMBER_CHARS = 40;
+const MIN_MEMBERS = 2;
+/** 一行に並べる名前の数として読む上限。括弧の年（Holland (1993): ...）を数に読まない。 */
+const MAX_ANNOUNCED = 99;
+
+/**
+ * 行頭（箇条書きの印の後ろでもよい）のラベル、括弧の中の数（数える語は付いても付かなくてもよい）、コロン。
+ * 括弧の中に数以外の語があるもの（約6名、6名以上、5名ほか）は形が合わず、ここで外れる。
+ */
+const headPattern = (words: CountWords): RegExp => {
+  const numbers = words.numbers.length === 0 ? "\\p{Nd}+" : `\\p{Nd}+|${alternation(words.numbers)}`;
+  const counter = words.counters.length === 0 ? "" : `(?:[ \\t]?(?<counter>${alternation(words.counters)})(?![A-Za-z]))?`;
+  const label = `(?<label>[^\\s\\p{Nd}(（:：|>#*+-][^(（:：\\n]{0,${MAX_LABEL_CHARS}})`;
+  const listMark = String.raw`(?:(?:[-*+]|\d{1,9}[.)])[ \t]+)?`;
+  return new RegExp(`^[ \\t]*${listMark}${label}[(（][ \\t]*(?<phrase>(?<number>${numbers})${counter})[ \\t]*[)）][ \\t]*[:：][ \\t]*`, "diu");
+};
+
+const LATIN_LETTER = /[A-Za-z]/u;
+
+/** 英語の語は語の切れ目で照らす（and が Anderson に当たらない）。日本語の語は字面どおり。atEnd なら末尾の語だけ。 */
+const wordPattern = (word: string, atEnd = false): RegExp => {
+  const before = LATIN_LETTER.test(word[0] ?? "") ? "(?<![A-Za-z])" : "";
+  const after = LATIN_LETTER.test(word.at(-1) ?? "") ? "(?![A-Za-z])" : "";
+  return new RegExp(`${before}${escapeRegExp(word)}${after}${atEnd ? "\\s*$" : ""}`, "iu");
+};
+
+const BRACKETED = /\([^()（）]*\)|（[^()（）]*）|「[^「」]*」|\[[^[\]]*\]/gu;
+const BRACKET = /[()（）「」[\]]/u;
+/** 並びの途中で文が切れる、別のラベルが始まる。名前の並びでなく文なので数えない。 */
+const NOT_A_NAME_LIST = /[。．.:：;；]/u;
+const TRAILING_END = /[。．.]\s*$/u;
+
+/** 括弧の中の注記（議長）を除いた並び。括弧が閉じていなければ undefined。 */
+const withoutNotes = (members: string): string | undefined => {
+  const stripped = members.replace(BRACKETED, "");
+  return BRACKET.test(stripped) ? undefined : stripped;
+};
+
+const hasAny = (text: string, words: readonly string[]): boolean => words.some((word) => wordPattern(word).test(text));
+
+/** 閉じていないことを言う語は名前の後ろに付く（田中ほか、etc）。名前の中の字（等々力）は数える。 */
+const endsOpen = (member: string, open: readonly string[]): boolean => open.some((word) => wordPattern(word, true).test(member));
+
+/** 最後の名前の前のつなぐ語（, and Ito）は並びの終わりの印で、名前の一部ではない。 */
+const withoutLeadingJoiner = (member: string, joiners: readonly string[]): string => {
+  const leading = joiners.find((joiner) => new RegExp(`^${escapeRegExp(joiner)}\\s+`, "iu").test(member));
+  return leading === undefined ? member : member.slice(leading.length).trimStart();
+};
+
+const splitMembers = (text: string, separators: readonly string[]): string[] =>
+  text.split(new RegExp(separators.map(escapeRegExp).join("|"), "u")).map((part) => part.trim());
+
+const withLastJoinerOff = (parts: readonly string[], joiners: readonly string[]): string[] => {
+  const last = parts.at(-1);
+  return last === undefined ? [...parts] : [...parts.slice(0, -1), withoutLeadingJoiner(last, joiners)];
+};
+
+const isNameLike = (member: string, words: MemberWords): boolean => member !== "" && member.length <= MAX_MEMBER_CHARS && !hasAny(member, words.joiners);
+
+/** 区切って並べた名前の数。並びとして読めないときは undefined。 */
+export const memberCount = (members: string, words: MemberWords): number | undefined => {
+  if (words.separators.length === 0) return undefined;
+  const notes = withoutNotes(members.trim().replace(TRAILING_END, ""));
+  if (notes === undefined || NOT_A_NAME_LIST.test(notes)) return undefined;
+  const parts = splitMembers(notes, words.separators);
+  if (parts.some((part) => endsOpen(part, words.open))) return undefined;
+  const names = withLastJoinerOff(parts, words.joiners);
+  return names.length >= MIN_MEMBERS && names.every((name) => isNameLike(name, words)) ? names.length : undefined;
+};
+
+/** 次の行に並びが続いてよい行。空行、箇条書き、見出し、引用、表の行は別のもの。 */
+const CONTINUATION = /^[ \t]*[^\s\-*+#>|]/u;
+
+const endsWithSeparator = (text: string, words: MemberWords): boolean => words.separators.some((separator) => text.trimEnd().endsWith(separator));
+
+/** 区切りで終わる行は、次の行に並びが続く。 */
+const membersFrom = (lines: readonly string[], next: number, soFar: string, words: MemberWords): string => {
+  const line = lines[next] ?? "";
+  return endsWithSeparator(soFar, words) && CONTINUATION.test(line) ? membersFrom(lines, next + 1, soFar + line, words) : soFar;
+};
+
+/**
+ * ラベルは短い名前（出席者、Attendees）。区切りを含むもの（Dunn, G.E. (1960):）は文献の著者で、番号で終わるもの（Step 2 (3):）は
+ * 番号の付いた項目。どちらも括弧の数は並べた名前の数ではない。
+ */
+const isLabel = (label: string, members: MemberWords): boolean =>
+  !/\p{Nd}\s*$/u.test(label) && !members.separators.some((separator) => label.includes(separator));
+
+/** 数える語の無い数（Attendees (6)）は、ラベル自身が数えるもの（attendees、items）を言うときだけ数。Appendix (3) は番号。 */
+const labelCounts = (label: string, counters: readonly string[]): boolean => counters.some((counter) => wordPattern(counter, true).test(label));
+
+type Line = { readonly text: string; readonly start: number };
+
+const linesOf = (text: string): Line[] => {
+  const starts = [0, ...[...text.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return text.split("\n").map((line, index) => ({ text: line, start: starts[index] ?? 0 }));
+};
+
+/** ラベルと括弧の数。phraseAt は行の中の数の位置、rest はコロンの後ろ。 */
+type Head = { readonly phrase: string; readonly phraseAt: number; readonly announced: number; readonly rest: string };
+
+/** 数える語が数に付いているか、ラベルが数えるものを言っている（Attendees (6)）ときだけ、括弧の数を名前の数に読む。 */
+const isCount = (announced: number, counter: string | undefined, label: string, words: CountWords): boolean =>
+  (counter !== undefined || labelCounts(label, words.counters)) && announced >= 1 && announced <= MAX_ANNOUNCED;
+
+const headOf = (text: string, head: RegExp, words: CountWords, members: MemberWords): Head | undefined => {
+  const match = head.exec(text);
+  const groups = match?.groups;
+  const phraseAt = match?.indices?.groups?.["phrase"]?.[0];
+  const label = groups?.["label"] ?? "";
+  if (match === null || groups === undefined || phraseAt === undefined || !isLabel(label, members)) return undefined;
+  const announced = valueOf(groups["number"] ?? "", words.numbers);
+  if (!isCount(announced, groups["counter"], label, words)) return undefined;
+  return { phrase: (groups["phrase"] ?? "").trim(), phraseAt, announced, rest: text.slice(match[0].length) };
+};
+
+/** 本文（コードや強調の印を空白で覆ったもの）の、一行に並べた名前の予告で、数が合わないもの。 */
+export const inlineCountMismatches = (text: string, words: CountWords, members: MemberWords): CountMismatch[] => {
+  const head = headPattern(words);
+  const lines = linesOf(text);
+  const texts = lines.map((line) => line.text);
+  return lines.flatMap((line, index) => {
+    const found = headOf(line.text, head, words, members);
+    const listed = found === undefined ? undefined : memberCount(membersFrom(texts, index + 1, found.rest, members), members);
+    if (found === undefined || listed === undefined || listed === found.announced) return [];
+    return [{ offset: line.start + found.phraseAt, phrase: found.phrase, announced: found.announced, listed }];
+  });
+};

package/src/kana-spelling.ts

@@ -15,6 +15,13 @@ export const isKanaOnly = (text: string): boolean => KANA_ONLY.test(text);
 /** The kanji of a spelling, in order: 引越 for both 引っ越し and 引越し, nothing for できる. */
 export const kanjiSkeleton = (text: string): string => [...text.matchAll(KANJI)].map((match) => match[0]).join("");
 
+/**
+ * Whether a spelling is the kanji alone of a word the others spell with okurigana: 取扱 beside 取扱い, 締切 beside 締切り. Official
+ * Japanese drops okurigana at the head of a compound (取扱事業者) and keeps it on the word alone, so the two are one convention.
+ */
+export const dropsOkurigana = (spelling: string, spellings: readonly string[]): boolean =>
+  spelling !== "" && kanjiSkeleton(spelling) === spelling && spellings.some((other) => other !== spelling && kanjiSkeleton(other) === spelling);
+
 /** The length, in UTF-16 units, of the start both strings share, compared character by character (𠮟 is one character, two units). */
 const sharedPrefixLength = (left: string, right: string): number => {
   const [leftChars, rightChars] = [[...left], [...right]];

package/src/location-part.ts

@@ -0,0 +1,30 @@
+import type { Span, Token } from "./plugin.ts";
+
+/** 空白の前の、建物や場所の名前になる語の品詞。助詞の後ろ（「会場は 5階」）は名前の区切りではない。 */
+const NAME_POS = new Set(["NOUN", "PROPN"]);
+
+/** 階・部屋の番号の後ろに続けば、番号が語の一部（5階建て、5階です）で、所在の組を閉じていない字。 */
+const WORD_CHAR = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u;
+
+const SPACES = new Set([" ", "　"]);
+
+/** units は階・部屋の番号の単位（語彙表 floor-unit）、levels は番号の前に書いて階の名前の一部になる語（語彙表 floor-level）。 */
+export type FloorWords = { readonly units: ReadonlySet<string>; readonly levels: ReadonlySet<string> };
+
+/** run のすぐ後ろに書いた、units のうち最も長い語。無ければ undefined。 */
+const unitAfter = (text: string, run: Span, units: ReadonlySet<string>): string | undefined =>
+  [...units].filter((unit) => text.startsWith(unit, run.end)).toSorted((left, right) => right.length - left.length)[0];
+
+/**
+ * 「本社 5階 第2会議室」「研究所 3階 セミナー室」のように、名前の語の後ろに空白で区切って書いた階・部屋の番号。
+ * その前の空白は所在の組を分ける区切りで、日本語と数字のあいだの空け方の好みではない。「地下 1階」「地上 5階」の空白は階の名前の中の空け方なので、区切りと読まない。
+ * 番号は数字だけで、単位の後ろで組が閉じる（空白・読点・文末・英字が続く）ものだけ。tokens は文書全体の座標で、base は text の先頭の位置。
+ */
+export const isSpacedLocationPart = (text: string, run: Span, tokens: readonly Token[] | undefined, base: number, words: FloorWords): boolean => {
+  if (tokens === undefined || !SPACES.has(text[run.start - 1] ?? "")) return false;
+  if (!/^\d+$/u.test(text.slice(run.start, run.end))) return false;
+  const unit = unitAfter(text, run, words.units);
+  if (unit === undefined || WORD_CHAR.test(text[run.end + unit.length] ?? "")) return false;
+  const named = tokens.find((token) => token.span.end === base + run.start - 1);
+  return named !== undefined && NAME_POS.has(named.pos) && !words.levels.has(named.surface);
+};