chaffjs 0.29.0 → 0.31.0

package/src/return-type.ts

@@ -0,0 +1,361 @@
+// One function's return type stated two ways on one page: the signature in a code block against a "Returns:" line, a
+// table's return column, or a sentence ("measure returns a string", 「measure は文字列を返します」). Pure; reads the
+// Markdown source. The words (Returns, 戻り値, returns, 返します, は, and the type words string, 文字列) come from the
+// language's lexicons. A statement is compared only with the signatures of the function it names, and only when both
+// sides are readable. The signature reader is small and TypeScript/Python-shaped; it may later be shared with
+// parameter-table.ts.
+
+/** The words of one language that state a return type. `kinds` maps a lower-cased type word to a kind (string, array). */
+export type ReturnWords = {
+  readonly labels: readonly string[];
+  readonly verbs: readonly string[];
+  /** What may follow the function's name before the verb (は, が); none for a language that puts the verb first. */
+  readonly subjects: readonly string[];
+  readonly kinds: ReadonlyMap<string, string>;
+  /** Words opening a clause about when (when, とき): a type word on the far side of one names the input, not the result. */
+  readonly clauses: readonly string[];
+  /** Words making the type word before them one item of the result (per, ごと). */
+  readonly items: readonly string[];
+};
+
+/** A statement that disagrees with every signature of its function: what it says, what a signature says, and where. */
+export type ReturnTypeClash = { readonly fn: string; readonly stated: string; readonly signature: string; readonly offset: number };
+
+/** A return type as written: a type in code (`string[]`), or the kind a type word names (a string → string). */
+type Stated = { readonly code: string; readonly written: string } | { readonly kind: string; readonly written: string };
+
+type Statement = { readonly fn: string; readonly stated: Stated; readonly offset: number };
+type Signature = { readonly fn: string; readonly params: string; readonly returns: string; readonly offset: number };
+type Line = { readonly text: string; readonly start: number; readonly fenced: boolean; readonly section: number };
+
+const FENCE = /^ {0,3}(`{3,}|~{3,})/u;
+const HEADING = /^ {0,3}#{1,6}[ \t]/u;
+const TABLE_ROW = /^[ \t]{0,3}\|/u;
+const DELIMITER_ROW = /^[ \t]{0,3}\|?[ \t]*:?-{3,}/u;
+const IDENTIFIER = /^[A-Za-z_$][\w$]*/u;
+const DECLARATION_HEAD = /^(?:(?:export|default|declare|async|public|static)\s+)*(?:(?:function\*?|def|fn|func)\s+)?/u;
+const ARROW_HEAD = /^(?:(?:export|declare)\s+)*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?/u;
+const RETURN_MARK = /^\s*(?::|->)\s*/u;
+/** What may close a declaration line after its return type: an arrow's `=>` or a body's `{` with what follows, `;`, Python's `:`. */
+const withoutDeclarationTail = (text: string): string => {
+  const cut = [text.indexOf("=>"), text.indexOf("{")].filter((at) => at !== -1);
+  const head = (cut.length === 0 ? text : text.slice(0, Math.min(...cut))).trim();
+  return head.endsWith(";") || head.endsWith(":") ? head.slice(0, -1).trim() : head;
+};
+const GENERICS = /^<[^<>()]*>/u;
+const TYPE_NAME = String.raw`[A-Za-z_$][\w$.]*(?:<[\w$.,\s<>[\]|]*>|\[[\w$.,\s[\]|]*\])?(?:\[\])*`;
+/** A type as code writes it: names, generic arguments, array brackets, and unions of those. */
+const TYPE_TEXT = new RegExp(String.raw`^${TYPE_NAME}(?:\s*\|\s*${TYPE_NAME})*$`, "u");
+/** Where a sentence ends, so a type word of the next sentence is not read as this one's. */
+const SENTENCE_END = /[。！？!?;]|\.(?=\s|$)/u;
+const NOTHING_TYPES: ReadonlySet<string> = new Set(["null", "undefined", "void", "None"]);
+/** The kind of a type name in code; a name not listed (a class, a generic parameter, Promise<…>) has none. */
+const CODE_KINDS: ReadonlyMap<string, string> = new Map([
+  ["string", "string"],
+  ["str", "string"],
+  ["number", "number"],
+  ["int", "number"],
+  ["float", "number"],
+  ["bigint", "number"],
+  ["boolean", "boolean"],
+  ["bool", "boolean"],
+  ["list", "array"],
+  ["tuple", "array"],
+]);
+
+const linesOf = (source: string): Line[] => {
+  const state = { start: 0, fence: "", section: 0 };
+  return source.split("\n").map((text) => {
+    const start = state.start;
+    state.start += text.length + 1;
+    const mark = FENCE.exec(text)?.[1];
+    const closes = mark !== undefined && state.fence !== "" && mark[0] === state.fence[0] && mark.length >= state.fence.length;
+    if (mark !== undefined && (state.fence === "" || closes)) {
+      state.fence = closes ? "" : mark;
+      return { text, start, fenced: true, section: state.section };
+    }
+    if (state.fence === "" && HEADING.test(text)) state.section += 1;
+    return { text, start, fenced: state.fence !== "", section: state.section };
+  });
+};
+
+/** The index of the ) that closes the ( at `open`, or -1. */
+const closingParen = (text: string, open: number): number => {
+  const state = { depth: 0, at: -1 };
+  Array.from(text.slice(open)).some((char, index) => {
+    if (char === "(") state.depth += 1;
+    if (char === ")") state.depth -= 1;
+    if (state.depth === 0) state.at = open + index;
+    return state.depth === 0;
+  });
+  return state.at;
+};
+
+const squeeze = (text: string): string => text.replace(/\s+/gu, "");
+
+/** `Array<string>` is `string[]`: the inner generic first, so Array<Array<string>> becomes string[][]. */
+const withoutArrayGenerics = (type: string): string => {
+  const next = type.replace(/(?<![\w$.])Array<([^<>]*)>/u, (_whole, inner: string) => (inner.includes("|") ? `(${inner})[]` : `${inner}[]`));
+  return next === type ? type : withoutArrayGenerics(next);
+};
+
+/** The members of a union at its top level, outside brackets. */
+const unionMembers = (type: string): string[] => {
+  const state = { depth: 0, from: 0 };
+  const members: string[] = [];
+  Array.from(type).forEach((char, index) => {
+    if ("(<[{".includes(char)) state.depth += 1;
+    if (")>]}".includes(char)) state.depth -= 1;
+    if (char !== "|" || state.depth !== 0) return;
+    members.push(type.slice(state.from, index));
+    state.from = index + 1;
+  });
+  return [...members, type.slice(state.from)].filter((member) => member !== "");
+};
+
+/** A code type's members in one spelling: no spaces, Array<T> as T[], sorted. */
+export const typeMembers = (type: string): string[] =>
+  unionMembers(withoutArrayGenerics(squeeze(type))).toSorted((left, right) => left.localeCompare(right, "en"));
+
+/** The kind of one member, or undefined when its name says nothing a type word could (WrapResult, T, Promise<…>). */
+const kindOfMember = (member: string): string | undefined => {
+  if (member.endsWith("[]") || /^(?:list|List|tuple|Tuple)\[/u.test(member)) return "array";
+  return CODE_KINDS.get(member);
+};
+
+/**
+ * A type in a sentence or a cell is read only when it can be a type and not a parameter's name: each member has a kind, is
+ * null or the like, or is a capitalised name (WrapResult). `text` is a name, and `null` alone says when, not what.
+ */
+const isReadableCode = (type: string): boolean => {
+  const members = typeMembers(type);
+  const readable = members.every((member) => kindOfMember(member) !== undefined || NOTHING_TYPES.has(member) || /^[A-Z]/u.test(member));
+  return TYPE_TEXT.test(type.trim()) && readable && members.some((member) => !NOTHING_TYPES.has(member));
+};
+
+const declaredAt = (line: string): { readonly fn: string; readonly afterName: number } | undefined => {
+  const arrow = ARROW_HEAD.exec(line);
+  if (arrow?.[1] !== undefined) return { fn: arrow[1], afterName: arrow[0].length };
+  const headLength = DECLARATION_HEAD.exec(line)?.[0].length ?? 0;
+  const fn = IDENTIFIER.exec(line.slice(headLength))?.[0];
+  return fn === undefined ? undefined : { fn, afterName: headLength + fn.length };
+};
+
+/** A declaration with a return type (`wrap(text: string): string[]`, `def f(x) -> str:`); a call has none. */
+export const signatureOf = (line: string, offset = 0): Signature | undefined => {
+  const declared = declaredAt(line);
+  if (declared === undefined) return undefined;
+  const open = declared.afterName + (GENERICS.exec(line.slice(declared.afterName))?.[0].length ?? 0);
+  const close = line[open] === "(" ? closingParen(line, open) : -1;
+  const mark = close === -1 ? null : RETURN_MARK.exec(line.slice(close + 1));
+  if (close === -1 || mark === null) return undefined;
+  const returns = withoutDeclarationTail(line.slice(close + 1 + mark[0].length));
+  return TYPE_TEXT.test(returns) ? { fn: declared.fn, params: squeeze(line.slice(open + 1, close)), returns, offset } : undefined;
+};
+
+const signaturesOf = (lines: readonly Line[]): Signature[] =>
+  lines.flatMap((line) => {
+    const lead = line.text.length - line.text.trimStart().length;
+    const signature = line.fenced ? signatureOf(line.text.trim(), line.start + lead) : undefined;
+    return signature === undefined ? [] : [signature];
+  });
+
+const escaped = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`);
+
+const isSpaced = (word: string): boolean => /^[A-Za-z]/u.test(word);
+
+/** A word's occurrences: whole words where words are spaced, any occurrence where they are not. */
+const wordPattern = (word: string): RegExp => (isSpaced(word) ? new RegExp(String.raw`\b${escaped(word)}\b`, "giu") : new RegExp(escaped(word), "gu"));
+
+const startsWithWord = (text: string, word: string): boolean =>
+  isSpaced(word) ? new RegExp(String.raw`^${escaped(word)}\b`, "iu").test(text) : text.startsWith(word);
+
+/** "returns true when …" is a boolean: a literal says its kind in any language, in code or not. */
+const LITERAL_KINDS: ReadonlyMap<string, string> = new Map([
+  ["true", "boolean"],
+  ["false", "boolean"],
+]);
+
+/** Whether `word` stands in `text` as a whole value, not followed by a word making it one item (string per line). */
+const namesWhole = (text: string, word: string, items: readonly string[]): boolean =>
+  [...text.matchAll(wordPattern(word))].some((match) => {
+    const next = text.slice(match.index + match[0].length).trimStart();
+    return !items.some((item) => startsWithWord(next, item));
+  });
+
+/** The type words in a stretch of text, outside code spans other than a literal (`false`). */
+const typeWordsIn = (text: string, words: ReturnWords): [string, string][] => {
+  const bare = text.replace(/`([^`]*)`/gu, (_whole, inner: string) => (LITERAL_KINDS.has(inner.toLowerCase()) ? ` ${inner} ` : " "));
+  return [...words.kinds, ...LITERAL_KINDS].filter(([word]) => namesWhole(bare, word, words.items));
+};
+
+/** A language with no subject words (en) puts the verb right after the name, and a clause about when after the result. */
+const isVerbFirst = (words: ReturnWords): boolean => words.subjects.length === 0;
+
+/**
+ * The part of a statement that can name what is returned, without a clause about when (when …, …とき): before the first
+ * clause word where the verb comes first, after the last where the verb comes last.
+ */
+const returnedPart = (text: string, words: ReturnWords): string => {
+  const cuts = words.clauses.flatMap((word) =>
+    [...text.matchAll(wordPattern(word))].map((match) => ({ from: match.index, to: match.index + match[0].length })),
+  );
+  if (cuts.length === 0) return text;
+  return isVerbFirst(words) ? text.slice(0, Math.min(...cuts.map((cut) => cut.from))) : text.slice(Math.max(...cuts.map((cut) => cut.to)));
+};
+
+/** The one kind a stretch's type words name. */
+const kindIn = (text: string, returnWords: ReturnWords): Stated | undefined => {
+  const words = typeWordsIn(text, returnWords);
+  const named = new Set(words.map(([, kind]) => kind));
+  return named.size === 1 && words[0] !== undefined ? { kind: words[0][1], written: words[0][0] } : undefined;
+};
+
+/** What a stretch of text says is returned: one readable code span, else the one kind its type words name. */
+const statedIn = (text: string, words: ReturnWords): Stated | undefined => {
+  const trimmed = returnedPart(text, words).trim();
+  if (TYPE_TEXT.test(trimmed) && isReadableCode(trimmed)) return { code: trimmed, written: trimmed };
+  const spans = new Set([...trimmed.matchAll(/`([^`]+)`/gu)].map((match) => match[1] ?? "").filter(isReadableCode));
+  if (spans.size === 1) return { code: [...spans][0] ?? "", written: [...spans][0] ?? "" };
+  return spans.size === 0 ? kindIn(trimmed, words) : undefined;
+};
+
+const firstSentence = (text: string): string => text.split(SENTENCE_END)[0] ?? "";
+
+const lineOf = (lines: readonly Line[], offset: number): Line | undefined =>
+  lines.find((line) => line.start <= offset && offset <= line.start + line.text.length);
+
+/** The function each section's "Returns:" line is about: the one function its code blocks declare. */
+const sectionFunctions = (lines: readonly Line[], signatures: readonly Signature[]): Map<number, string> => {
+  const bySection = new Map<number, Set<string>>();
+  signatures.forEach((signature) => {
+    const section = lineOf(lines, signature.offset)?.section ?? -1;
+    bySection.set(section, (bySection.get(section) ?? new Set<string>()).add(signature.fn));
+  });
+  return new Map([...bySection].flatMap(([section, names]): [number, string][] => (names.size === 1 ? [[section, [...names].join("")]] : [])));
+};
+
+const labelPattern = (labels: readonly string[]): RegExp =>
+  new RegExp(String.raw`^[ \t]*(?:[-*+][ \t]+)?(?:\*\*|__)?(?:${labels.map(escaped).join("|")})(?:\*\*|__)?[ \t]*[:：](?:\*\*|__)?`, "iu");
+
+/** A "Returns:" line under a heading whose code blocks declare one function. */
+const labelStatements = (lines: readonly Line[], functions: ReadonlyMap<number, string>, words: ReturnWords): Statement[] => {
+  if (words.labels.length === 0) return [];
+  const label = labelPattern(words.labels);
+  return lines.flatMap((line) => {
+    const head = line.fenced ? null : label.exec(line.text);
+    const fn = functions.get(line.section);
+    if (head === null || fn === undefined) return [];
+    const stated = statedIn(firstSentence(line.text.slice(head[0].length)), words);
+    return stated === undefined ? [] : [{ fn, stated, offset: line.start }];
+  });
+};
+
+const cellsOf = (row: string): string[] => row.trim().replace(/^\|/u, "").replace(/\|$/u, "").split("|");
+
+const cellText = (cell: string): string => cell.trim().replace(/^(?:\*\*|__)(.*)(?:\*\*|__)$/u, "$1");
+
+/** The function a table row names in its first cell: `wrap`, wrap(), `measure(text)`. */
+const rowFunction = (cell: string): string => {
+  const name = cellText(cell).replace(/`/gu, "").trim();
+  const open = name.indexOf("(");
+  return name.endsWith(")") && open > 0 ? name.slice(0, open).trim() : name;
+};
+
+/** A table with a return column (Returns, 戻り値) whose rows name functions in their first cell. */
+const tableStatements = (lines: readonly Line[], known: ReadonlySet<string>, words: ReturnWords): Statement[] => {
+  const labels = new Set(words.labels.map((label) => label.toLowerCase()));
+  const state = { column: -1 };
+  return lines.flatMap((line, index) => {
+    if (line.fenced || !TABLE_ROW.test(line.text)) {
+      state.column = -1;
+      return [];
+    }
+    if (DELIMITER_ROW.test(line.text)) {
+      state.column = cellsOf(lines[index - 1]?.text ?? "").findIndex((cell) => labels.has(cellText(cell).toLowerCase()));
+      return [];
+    }
+    const cells = cellsOf(line.text);
+    const fn = rowFunction(cells[0] ?? "");
+    const stated = state.column > 0 && known.has(fn) ? statedIn(cells[state.column] ?? "", words) : undefined;
+    return stated === undefined ? [] : [{ fn, stated, offset: line.start }];
+  });
+};
+
+/** `measure returns …` / 「measure は … 返します」: the function's name, an optional subject word, then the verb. */
+const sentencePattern = (fn: string, words: ReturnWords): RegExp => {
+  const subject = words.subjects.length === 0 ? "" : String.raw`(?:(?:${words.subjects.map(escaped).join("|")})[、,]?)?`;
+  const verbs = words.verbs.map(escaped).join("|");
+  return new RegExp(String.raw`(?<![\w$.])\x60?${escaped(fn)}(?:\(\))?\x60?\s*${subject}([^。！？!?;]*?)(?:${verbs})(?![\p{L}\p{N}])`, "gu");
+};
+
+/** A sentence whose subject is a function's name and whose verb says it returns something. */
+const sentenceStatements = (lines: readonly Line[], known: ReadonlySet<string>, words: ReturnWords): Statement[] => {
+  if (words.verbs.length === 0) return [];
+  const prose = lines.filter((line) => !line.fenced && !HEADING.test(line.text) && !TABLE_ROW.test(line.text));
+  return [...known].flatMap((fn) =>
+    prose.flatMap((line) =>
+      [...line.text.matchAll(sentencePattern(fn, words))].flatMap((match) => {
+        const between = match[1] ?? "";
+        // Where the verb comes first, nothing stands between the name and the verb.
+        const verbFirst = isVerbFirst(words);
+        if (verbFirst && between.trim() !== "") return [];
+        const after = firstSentence(line.text.slice(match.index + match[0].length));
+        const stated = statedIn(verbFirst ? after : between, words);
+        return stated === undefined ? [] : [{ fn, stated, offset: line.start + match.index }];
+      }),
+    ),
+  );
+};
+
+const isSubset = (small: readonly string[], large: readonly string[]): boolean => small.every((member) => large.includes(member));
+
+/** Whether a statement can be the signature's return type; true when either side is too vague to say otherwise. */
+const agrees = (stated: Stated, returns: string): boolean => {
+  const members = typeMembers(returns);
+  if ("code" in stated) {
+    const said = typeMembers(stated.code);
+    return isSubset(said, members);
+  }
+  const kinds = members.filter((member) => !NOTHING_TYPES.has(member)).map(kindOfMember);
+  return kinds.includes(undefined) || kinds.includes(stated.kind);
+};
+
+const clashOf = (fn: string, stated: string, signature: Signature, offset: number): ReturnTypeClash => ({
+  fn,
+  stated,
+  signature: signature.returns,
+  offset,
+});
+
+/** Two declarations with the same parameters and different return types; overloads (other parameters) are left alone. */
+const signatureClashes = (signatures: readonly Signature[]): ReturnTypeClash[] =>
+  signatures.flatMap((later, index) => {
+    const earlier = signatures
+      .slice(0, index)
+      .find(
+        (signature) =>
+          signature.fn === later.fn && signature.params === later.params && typeMembers(signature.returns).join("|") !== typeMembers(later.returns).join("|"),
+      );
+    return earlier === undefined ? [] : [clashOf(later.fn, later.returns, earlier, later.offset)];
+  });
+
+/** Every place on the page that states a function's return type differently from all of the function's signatures. */
+export const returnTypeClashes = (source: string, words: ReturnWords): ReturnTypeClash[] => {
+  const lines = linesOf(source);
+  const signatures = signaturesOf(lines);
+  const known = new Set(signatures.map((signature) => signature.fn));
+  const statements = [
+    ...labelStatements(lines, sectionFunctions(lines, signatures), words),
+    ...tableStatements(lines, known, words),
+    ...sentenceStatements(lines, known, words),
+  ];
+  const statementClashes = statements.flatMap((statement) => {
+    const own = signatures.filter((signature) => signature.fn === statement.fn);
+    const first = own[0];
+    return first === undefined || own.some((signature) => agrees(statement.stated, signature.returns))
+      ? []
+      : [clashOf(statement.fn, statement.stated.written, first, statement.offset)];
+  });
+  return [...signatureClashes(signatures), ...statementClashes].toSorted((left, right) => left.offset - right.offset);
+};

package/src/spacing-code.ts

@@ -0,0 +1,26 @@
+import type { Span } from "./plugin.ts";
+
+// Text beside which a space is not a spacing choice: a clock time (13:30), which like 3時 names a time rather than a
+// quantity, and an e-mail address or a URL, whose end a reader and an auto-linker find by the space after it. Pure.
+
+/** A clock time: hours, a colon, minutes, and seconds optionally (9:05, 13:30, 08:00:15). */
+const CLOCK_TIME = /(?<![\d:：.])\d{1,2}[:：][0-5]\d(?:[:：][0-5]\d)?(?![\d:：])/gu;
+
+/** A run of printable ASCII without brackets: an address ends where Japanese text, a space or a bracket starts (…/faq で). */
+const ASCII_RUN = /[!-'*-~]+/gu;
+
+/** An e-mail address (a local part, @, and a domain with a dot) or a URL with its scheme or www. */
+const EMAIL = /^[\w.+-]+@[\w-]+\.[\w.-]+$/u;
+const URL_START = /^(?:https?:\/\/|www\.)/u;
+
+const isAddress = (word: string): boolean => EMAIL.test(word) || URL_START.test(word);
+
+const spansOf = (text: string, pattern: RegExp): Span[] =>
+  [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+export const clockTimeSpans = (text: string): Span[] => spansOf(text, CLOCK_TIME);
+
+export const addressSpans = (text: string): Span[] => spansOf(text, ASCII_RUN).filter((span) => isAddress(text.slice(span.start, span.end)));
+
+/** Whether the character at `at` is inside one of the spans. */
+export const isInsideSpan = (spans: readonly Span[], at: number): boolean => spans.some((span) => span.start <= at && at < span.end);

package/src/structure/amount-range.ts

@@ -1,11 +1,11 @@
-// amount-range-reversed: a range of amounts whose upper end is below its lower end (月給30万円〜25万円, $90,000–$70,000,
-// 下限30万円・上限25万円). The amounts come read (currency, value, the word of scale they carry); the words that join a range,
-// change a price, and label a bound come from the lexicons. Pure.
+// amount-range-reversed and quantity-range-reversed: a range whose upper end is below its lower end (月給30万円〜25万円,
+// $90,000–$70,000, 下限30万円・上限25万円, 5–2 kg, -10〜-40℃). The ends come read (currency or unit, value, the word of scale
+// they carry); the words that join a range, change a value, and label a bound come from the lexicons. Pure.
 import { escapeRegExp } from "../orthography.ts";
 import { amountValue, type ScaleWord } from "./amount-scale.ts";
 import type { StructureIssue } from "./issues.ts";
 
-/** One amount written with its currency. scale is the value of the word of scale written in it (万, million), if any. */
+/** One amount written with its currency (or a quantity with its unit, in currency). scale is the value of the word of scale written in it (万, million), if any. */
 export type RangeAmount = {
   readonly offset: number;
   readonly end: number;
@@ -27,7 +27,7 @@ export type AmountRangeWords = {
   readonly lowers: readonly string[];
   readonly uppers: readonly string[];
   readonly links: readonly string[];
-  /** The words of scale (万, million, k) and the digits of a number (the currency reader's pattern). */
+  /** The words of scale (万, million, k) and the digits of a number (the reader's pattern; a quantity's may open with a minus sign). */
   readonly scales: readonly ScaleWord[];
   readonly number: string;
 };
@@ -94,11 +94,20 @@ const alternation = (patterns: readonly string[]): string => patterns.toSorted((
 
 const scalePart = (words: AmountRangeWords): string => {
   const scales = alternation(words.scales.map((scale) => escapeRegExp(scale.word)));
-  return scales === "" ? "" : `(?:\\s?(${scales}))?`;
+  // With no words of scale the group still stands, never matching, so the joint keeps its group number.
+  return scales === "" ? "((?!))?" : `(?:\\s?(${scales}))?`;
 };
 
 const jointPart = (words: AmountRangeWords): string => `(\\s?(?:${alternation([...words.connectors, ...words.openers].map(wordPattern))})\\s?)`;
 
+const MINUS = /^[-−－]/u;
+
+/** The value of a bare number, negative when it opens with a minus sign (-10〜-40℃). */
+const signedValue = (digits: string): number | undefined => {
+  const value = amountValue(digits.replace(MINUS, ""), []);
+  return value === undefined || !MINUS.test(digits) ? value : -value;
+};
+
 /** A bare number (no currency) and its word of scale, if any. */
 const bareReading = (
   span: { readonly offset: number; readonly end: number },
@@ -106,7 +115,7 @@ const bareReading = (
   scaleWord: string | undefined,
   words: AmountRangeWords,
 ): Reading | undefined => {
-  const value = amountValue(digits, []);
+  const value = signedValue(digits);
   if (value === undefined) return undefined;
   const scale = scaleOf(scaleWord, words);
   return { ...span, value: scale === undefined ? value : value * scale, scale };

package/src/structure/capacity-count.ts

@@ -0,0 +1,196 @@
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 書いた定員より多い申込・招待・参加の人数（定員：90名 と 95名の方にお申し込み、Capacity: 90 seats と 95 members have registered）。
+ * 定員の語（定員、先着、capacity、limited to）と人数の語（申込、招待者、have registered）を付けた数だけを読み、語の無い数は読まない。
+ * 比べるのは、文書に定員が一つ（一つの値）だけ書いてあるときだけ。二つ以上あれば、どの人数がどの定員のものか決められない。
+ * 数える物の組が違う数（30組と45名）は比べない。キャンセル待ちや抽選の語が文書にあれば、定員を超える申込は書いたとおりのことなので
+ * 言わない。一回あたりの数（各回定員20名、20 per session）は、定員でも人数でも比べない。全体の人数と一回の定員は比べられない。
+ * 去年や前回の人数（昨年は120名が参加）は、この催しの人数ではないので読まない。語は言語パッケージの語彙表から受け取る。
+ */
+
+/** 語彙表の一語。position は数のどちら側に書くか。group は語の種類（数える物の組、place の付いた定員の語）。 */
+export type CountMark = { readonly pattern: string; readonly position?: "before" | "after" | undefined; readonly group?: string | undefined };
+
+export type CapacityWords = {
+  /** 定員の語。group が place のものは、席の数（seats、places）にだけ付く（there are 25 places）。 */
+  readonly capacities: readonly CountMark[];
+  /** 申込・招待・参加の人数の語。 */
+  readonly counts: readonly CountMark[];
+  /** 数える物の語（名、人、席、people、seats）。group は組（head は人、place は席で人と比べる、party は組や家族）。 */
+  readonly units: readonly CountMark[];
+  /** 文書にあれば定員を超える申込を言わない語（キャンセル待ち、抽選、waitlist）。 */
+  readonly overflows: readonly string[];
+  /** 同じ行にあれば一回・一日あたりの数だと言う語（各回、per session）。 */
+  readonly perSession: readonly string[];
+  /** 人数と同じ行にあれば別の時の人数だと言う語（昨年、前回、last year）。 */
+  readonly otherOccasions: readonly string[];
+  /** 人数の後ろの句にあれば、申し込んでいない人の数だと言う語（していません、not）。 */
+  readonly negations: readonly string[];
+};
+
+/** 句の切れ目。人数の後ろの打ち消しは、ここまでで探す。 */
+const CLAUSE_BREAK = /[。．.!?！？;；、,，\n]/u;
+
+const clauseAfter = (source: string, end: number): string => {
+  const rest = source.slice(end);
+  const cut = CLAUSE_BREAK.exec(rest)?.index ?? rest.length;
+  return rest.slice(0, cut);
+};
+
+/** 語の付いた数。unit は数える物の組で、単位を書かない数（capacity 30）は undefined。line はその数の行。 */
+export type LabelledCount = {
+  readonly start: number;
+  readonly end: number;
+  readonly value: number;
+  readonly unit: string | undefined;
+  readonly line: string;
+};
+
+const DIGIT = "[0-9０-９]";
+/** 整数（1,200 は千二百）。小数と、桁区切りの続きの途中からは読まない。 */
+const NUMBER = new RegExp(`(?<!${DIGIT}|[.,，．])${DIGIT}+(?:[,，]${DIGIT}{3})*(?!${DIGIT}|[.,，．]${DIGIT})`, "gu");
+
+/** 記号と空白を除いて、語と数の間に挟んでよいもの（定員：90名、定員は25名、capacity of 30、registrations: 45）。 */
+const BEFORE_GAP_WORDS: ReadonlySet<string> = new Set(["", "は", "が", "of", "is", "was", "at"]);
+const isBeforeGap = (gap: string): boolean => BEFORE_GAP_WORDS.has(lower(gap.replaceAll(/[\s:：=]/gu, "")));
+/** 数（と単位）と後ろの和語の間に挟んでよいもの（95名の方にお申し込み、28名のお申し込み）。 */
+const AFTER_GAP_CJK = /^(?:の方|の皆様|の皆さま)?(?:[にがの]|から)?[おご]?$/u;
+/** 数（と単位）と後ろの英語の間の語は三つまで（95 members have registered、28 children had already booked）。 */
+const AFTER_GAP_LATIN = /^(?:\s+[A-Za-z]+){0,3}\s+$/u;
+/** 英語の単位は数との間に空白を一つ置ける（90 seats）。 */
+const LATIN_UNIT_GAP = /^\s?/u;
+const WORD_NEXT = /^\s?[A-Za-z]/u;
+
+const LETTER = /[A-Za-z]/u;
+
+const lower = (text: string): string => text.toLowerCase();
+
+const isLatin = (word: string): boolean => LETTER.test(word.charAt(0));
+
+const numberOf = (digits: string): number => Number(digits.normalize("NFKC").replaceAll(/[,，]/gu, ""));
+
+const startsWithWord = (text: string, word: string): boolean =>
+  lower(text).startsWith(lower(word)) && !(LETTER.test(word.slice(-1)) && LETTER.test(text.charAt(word.length)));
+
+const endsWithWord = (text: string, word: string): boolean =>
+  lower(text).endsWith(lower(word)) && !(LETTER.test(word.charAt(0)) && LETTER.test(text.charAt(text.length - word.length - 1)));
+
+/** 英字の語は語の切れ目で照らす（past が pastry に当たらない）。 */
+const contains = (text: string, words: readonly string[]): boolean =>
+  words.some((word) =>
+    [...lower(text).matchAll(new RegExp(escapeRegExp(lower(word)), "gu"))].some(
+      (match) => startsWithWord(text.slice(match.index), word) && endsWithWord(text.slice(0, match.index + word.length), word),
+    ),
+  );
+
+type Unit = { readonly mark: CountMark; readonly end: number };
+
+/** 数のすぐ後ろの単位と、単位の終わりの位置。長い語から照らす。 */
+const unitAfter = (line: string, end: number, units: readonly CountMark[]): Unit | undefined =>
+  units
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((mark) => {
+      const gap = isLatin(mark.pattern) ? (LATIN_UNIT_GAP.exec(line.slice(end))?.[0].length ?? 0) : 0;
+      return startsWithWord(line.slice(end + gap), mark.pattern) ? [{ mark, end: end + gap + mark.pattern.length }] : [];
+    })[0];
+
+const labelBefore = (head: string, marks: readonly CountMark[]): CountMark | undefined =>
+  marks
+    .filter((mark) => mark.position !== "after")
+    .find((mark) => {
+      const at = lower(head).lastIndexOf(lower(mark.pattern));
+      const end = at + mark.pattern.length;
+      return at !== -1 && endsWithWord(head.slice(0, end), mark.pattern) && isBeforeGap(head.slice(end));
+    });
+
+const labelAfter = (tail: string, marks: readonly CountMark[]): CountMark | undefined =>
+  marks
+    .filter((mark) => mark.position === "after")
+    .find((mark) => {
+      const at = lower(tail).indexOf(lower(mark.pattern));
+      if (at === -1 || !startsWithWord(tail.slice(at), mark.pattern)) return false;
+      return (isLatin(mark.pattern) ? AFTER_GAP_LATIN : AFTER_GAP_CJK).test(tail.slice(0, at));
+    });
+
+/**
+ * 語の付いた数か。和語の語には単位が要る（定員90 は読まない）。英語の数は単位を書かなくてよいが、後ろに単位でない語が続けば
+ * 別の物の数（capacity 30 cars）。place の付いた語は席の数にだけ付く。
+ */
+const isLabelled = (label: CountMark | undefined, unit: Unit | undefined, after: string, afterLabel: CountMark | undefined): label is CountMark => {
+  if (label === undefined || (label.group === "place" && unit?.mark.group !== "place")) return false;
+  if (unit !== undefined) return true;
+  return isLatin(label.pattern) && (afterLabel !== undefined || !WORD_NEXT.test(after));
+};
+
+/** 一行の中の、語の付いた数。 */
+const labelledIn = (line: string, lineStart: number, marks: readonly CountMark[], units: readonly CountMark[]): LabelledCount[] =>
+  [...line.matchAll(NUMBER)].flatMap((match) => {
+    const unit = unitAfter(line, match.index + match[0].length, units);
+    const end = unit?.end ?? match.index + match[0].length;
+    const after = line.slice(end);
+    const afterLabel = labelAfter(after, marks);
+    if (!isLabelled(labelBefore(line.slice(0, match.index), marks) ?? afterLabel, unit, after, afterLabel)) return [];
+    return [{ start: lineStart + match.index, end: lineStart + end, value: numberOf(match[0]), unit: unit?.mark.group, line }];
+  });
+
+const linesOf = (source: string): { readonly text: string; readonly start: number }[] => {
+  const starts = [0, ...[...source.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ text: source.slice(start, (starts[index + 1] ?? source.length + 1) - 1), start }));
+};
+
+const readAll = (source: string, marks: readonly CountMark[], units: readonly CountMark[]): LabelledCount[] =>
+  linesOf(source).flatMap((line) => labelledIn(line.text, line.start, marks, units));
+
+/** 席（place）は人（head）と同じ組として比べる。単位を書かない数は人の数。 */
+export const comparableGroup = (unit: string | undefined): string => (unit === undefined || unit === "place" ? "head" : unit);
+
+/** 文書の中の、定員の語の付いた数。一回あたりの定員は除く。 */
+export const capacityStatements = (source: string, words: CapacityWords): LabelledCount[] =>
+  readAll(source, words.capacities, words.units).filter((reading) => !contains(reading.line, words.perSession));
+
+/** 文書の中の、人数の語の付いた数。一回あたりの人数と、別の時の人数は除く。 */
+export const countStatements = (source: string, words: CapacityWords): LabelledCount[] =>
+  readAll(source, words.counts, words.units).filter(
+    (reading) =>
+      !contains(reading.line, words.perSession) &&
+      !contains(reading.line, words.otherOccasions) &&
+      !contains(clauseAfter(source, reading.end), words.negations),
+  );
+
+/** 定員を超える人数のうち一番多いもの。定員が一つの値でなければ、比べない。 */
+export const overCapacity = (
+  capacities: readonly LabelledCount[],
+  counts: readonly LabelledCount[],
+): { readonly capacity: LabelledCount; readonly over: LabelledCount } | undefined => {
+  const capacity = capacities[0];
+  if (capacity === undefined || capacities.some((other) => other.value !== capacity.value)) return undefined;
+  const over = counts
+    .filter((count) => comparableGroup(count.unit) === comparableGroup(capacity.unit) && count.value > capacity.value)
+    .toSorted((left, right) => right.value - left.value)[0];
+  return over === undefined ? undefined : { capacity, over };
+};
+
+/** その位置を含む一番小さい節の原文。節が無ければ文書の全体。 */
+export const sectionAround = (source: string, offset: number, sections: readonly Span[]): string => {
+  const around = sections
+    .filter((section) => section.start <= offset && offset < section.end)
+    .toSorted((left, right) => left.end - left.start - (right.end - right.start))[0];
+  return around === undefined ? source : source.slice(around.start, around.end);
+};
+
+/**
+ * 定員より多い人数。キャンセル待ちや抽選の語のある節の定員と人数は読まない（定員を超える申込が書いたとおりのこと）。
+ * 節に限るのは、別の節の「抽選会」（催しの一つ）で比べるのをやめないため。定員の位置を指す。sections は節の範囲。
+ */
+export const countsOverCapacity = (source: string, words: CapacityWords, sections: readonly Span[] = []): StructureIssue[] => {
+  const settled = (reading: LabelledCount): boolean => !contains(sectionAround(source, reading.start, sections), words.overflows);
+  const capacities = capacityStatements(source, words);
+  if (!capacities.every(settled)) return [];
+  const found = overCapacity(capacities, countStatements(source, words).filter(settled));
+  if (found === undefined) return [];
+  const { capacity, over } = found;
+  return [{ offset: capacity.start, values: { capacity: source.slice(capacity.start, capacity.end), count: source.slice(over.start, over.end) } }];
+};