chaffjs 0.28.0 → 0.29.0

package/src/default-values.ts

@@ -0,0 +1,158 @@
+// One parameter's default stated two ways on a page: the signature says `width = 72`, the options table says 72, and the
+// prose says "`width` defaults to 80". Pure; reads the Markdown source. The words of a default column (Default, 既定値)
+// and of a default in prose (defaults to, の既定値は) come from the language's lexicons.
+import { codeFences } from "./detectors/code-fences.ts";
+
+/** Where a default is stated, from the most to the least authoritative: the code, a table, a sentence. */
+type Source = "code" | "table" | "prose";
+type Stated = { readonly name: string; readonly value: string; readonly offset: number; readonly source: Source };
+
+/** A default that disagrees with the one the code (or else a table) states. */
+export type DefaultSlip = { readonly name: string; readonly value: string; readonly offset: number; readonly expected: string };
+
+export type DefaultWords = { readonly headers: readonly string[]; readonly phrases: readonly string[] };
+
+type Line = { readonly text: string; readonly start: number };
+
+const RANK: Readonly<Record<Source, number>> = { code: 0, table: 1, prose: 2 };
+/** The values read: a code span, a quoted string, or a literal (a number, true, false, null). */
+const QUOTED: readonly RegExp[] = [/^`([^`]+)`/u, /^"([^"]*)"/u, /^'([^']*)'/u];
+const LITERAL = /^(?:-?\d+(?:\.\d+)?|true|false|True|False|null|none|None|undefined)(?!\w|\.\d)/u;
+const NAME_SPAN = /`([A-Za-z_$][\w$]*)`/gu;
+const IDENTIFIER = /^[A-Za-z_$][\w$]*/u;
+const SPREAD = /^(?:\.\.\.|\*{1,2})/u;
+/** How far after the name a default phrase may start: "`width` defaults to", "`width` の既定値は". */
+const PHRASE_REACH = 4;
+/** A declaration, not a call: a keyword first, or a return type after the list. A call's width=40 is an argument. */
+const KEYWORD_FIRST = /^[ \t]*(?:(?:export|async)[ \t]+)*(?:def|function\*?|fn|func)[ \t]/u;
+const RETURN_TYPE = /\)[ \t]*(?::|->)/u;
+const DELIMITER_ROW = /^[ \t|:-]+$/u;
+
+const linesOf = (source: string): Line[] => {
+  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 valueAt = (text: string): string | undefined => {
+  const trimmed = text.trimStart();
+  const quoted = QUOTED.map((pattern) => pattern.exec(trimmed)?.[1]).find((value) => value !== undefined);
+  return quoted ?? LITERAL.exec(trimmed)?.[0];
+};
+
+/** The text between a line's first ( and the ) that closes it. */
+const parameterList = (text: string): { readonly list: string; readonly from: number } | undefined => {
+  const open = text.indexOf("(");
+  const state = { depth: 0, close: -1 };
+  Array.from(text.slice(open)).some((char, index) => {
+    if (char === "(") state.depth += 1;
+    if (char === ")") state.depth -= 1;
+    if (state.depth === 0) state.close = open + index;
+    return state.depth === 0;
+  });
+  return open === -1 || state.close === -1 ? undefined : { list: text.slice(open + 1, state.close), from: open + 1 };
+};
+
+/** width = 72, width: int = 72, *args: a parameter's name and its default value, if it has one. */
+const parameterDefault = (part: string): { readonly name: string; readonly value: string } | undefined => {
+  const trimmed = part.trim().replace(SPREAD, "");
+  const name = IDENTIFIER.exec(trimmed)?.[0];
+  const equals = trimmed.search(/=(?!=)/u);
+  const value = equals === -1 ? undefined : valueAt(trimmed.slice(equals + 1));
+  return name === undefined || value === undefined ? undefined : { name, value };
+};
+
+const QUOTES = "\"'`";
+
+/** A parameter list split at its commas, leaving a comma inside quotes or brackets (sep = ", ") in its parameter. */
+const splitParameters = (list: string): string[] => {
+  const state = { quote: "", depth: 0, from: 0 };
+  const parts: string[] = [];
+  [...list].forEach((char, index) => {
+    if (state.quote !== "") {
+      if (char === state.quote) state.quote = "";
+      return;
+    }
+    if (QUOTES.includes(char)) state.quote = char;
+    if ("([{".includes(char)) state.depth += 1;
+    if (")]}".includes(char)) state.depth -= 1;
+    if (char !== "," || state.depth !== 0) return;
+    parts.push(list.slice(state.from, index));
+    state.from = index + 1;
+  });
+  return [...parts, list.slice(state.from)];
+};
+
+const isDeclaration = (text: string): boolean => KEYWORD_FIRST.test(text) || RETURN_TYPE.test(text);
+
+const inCodeLine = (line: Line, base: number): Stated[] => {
+  const params = isDeclaration(line.text) ? parameterList(line.text) : undefined;
+  if (params === undefined) return [];
+  return splitParameters(params.list).flatMap((part, index, parts) => {
+    const found = parameterDefault(part);
+    const from = params.from + parts.slice(0, index).reduce((length, earlier) => length + earlier.length + 1, 0);
+    return found === undefined ? [] : [{ ...found, offset: base + line.start + line.text.indexOf(found.name, from), source: "code" as const }];
+  });
+};
+
+const inCode = (source: string): Stated[] =>
+  codeFences(source).flatMap((fence) => linesOf(source.slice(fence.start, fence.end)).flatMap((line) => inCodeLine(line, fence.start)));
+
+const cellsOf = (text: string): string[] =>
+  text
+    .split("|")
+    .slice(1, -1)
+    .map((cell) => cell.trim());
+
+/** The rows of every table with a default column, as (first cell name, default cell). */
+const inTables = (lines: readonly Line[], headers: ReadonlySet<string>): Stated[] =>
+  lines.flatMap((line, index) => {
+    const column = cellsOf(line.text).findIndex((cell) => headers.has(cell.replace(/[*`]/gu, "").toLowerCase()));
+    const delimiter = lines[index + 1]?.text ?? "";
+    if (column <= 0 || !delimiter.includes("---") || !DELIMITER_ROW.test(delimiter)) return [];
+    const end = lines.findIndex((row, at) => at > index + 1 && !row.text.trimStart().startsWith("|"));
+    return lines.slice(index + 2, end === -1 ? lines.length : end).flatMap((row) => {
+      const cells = cellsOf(row.text);
+      const name = /^`?([A-Za-z_$][\w$]*)`?$/u.exec(cells[0] ?? "")?.[1];
+      const value = valueAt(cells[column] ?? "");
+      return name === undefined || value === undefined ? [] : [{ name, value, offset: row.start + row.text.indexOf(name), source: "table" as const }];
+    });
+  });
+
+/** "`width` defaults to 80", "`width` の既定値は 80 文字": a code name, a default phrase right after it, then the value. */
+const inProse = (lines: readonly Line[], phrases: readonly string[]): Stated[] =>
+  lines.flatMap((line) =>
+    [...line.text.matchAll(NAME_SPAN)].flatMap((match) => {
+      const after = line.text.slice(match.index + match[0].length);
+      const phrase = phrases.map((candidate) => ({ candidate, at: after.toLowerCase().indexOf(candidate) })).find(({ at }) => at !== -1 && at <= PHRASE_REACH);
+      const value = phrase === undefined ? undefined : valueAt(after.slice(phrase.at + phrase.candidate.length));
+      return value === undefined ? [] : [{ name: match[1] ?? "", value, offset: line.start + match.index + 1, source: "prose" as const }];
+    }),
+  );
+
+/** Python writes the same literals capitalised: True is true, None is null. */
+const LITERAL_SPELLINGS: Readonly<Record<string, string>> = { True: "true", False: "false", None: "null", none: "null" };
+
+const normalized = (value: string): string => LITERAL_SPELLINGS[value] ?? value;
+
+const sameValue = (left: string, right: string): boolean =>
+  normalized(left) === normalized(right) || (Number.isFinite(Number(left)) && Number(left) === Number(right) && left !== "" && right !== "");
+
+/**
+ * Every stated default that differs from the name's most authoritative statement (the code, else a table). Two
+ * sentences that disagree with no code or table to settle it are left alone.
+ */
+export const defaultSlips = (source: string, words: DefaultWords): DefaultSlip[] => {
+  const fences = codeFences(source);
+  const lines = linesOf(source).filter((line) => !fences.some((fence) => line.start >= fence.start && line.start < fence.end));
+  const stated = [...inCode(source), ...inTables(lines, new Set(words.headers)), ...inProse(lines, words.phrases)];
+  return stated.flatMap((statement) => {
+    const above = stated.filter((other) => other.name === statement.name && RANK[other.source] < RANK[statement.source]);
+    const top = Math.min(...above.map((other) => RANK[other.source]));
+    const authorities = above.filter((other) => RANK[other.source] === top);
+    // Two functions on one page may give one parameter name two defaults; then no statement settles the others.
+    const authority = authorities.every((other) => sameValue(other.value, authorities[0]?.value ?? "")) ? authorities[0] : undefined;
+    return authority === undefined || sameValue(authority.value, statement.value)
+      ? []
+      : [{ name: statement.name, value: statement.value, offset: statement.offset, expected: authority.value }];
+  });
+};

package/src/deprecated-use.ts

@@ -0,0 +1,122 @@
+// A name the document calls deprecated (`indent` is deprecated; | `indent` | 0 | 非推奨 |) still used in one of its code
+// examples ({ indent: 2 }, --indent, indent=2). Pure; reads the Markdown source. The words that mark a name deprecated
+// (deprecated, 非推奨) and the phrases that negate them come from the language's lexicons.
+import { codeFences } from "./detectors/code-fences.ts";
+
+/** A deprecated name used in code: where it is used, and where the document calls it deprecated. */
+export type DeprecatedUse = { readonly name: string; readonly offset: number; readonly marked: number };
+
+/** The lowercase words that mark a name deprecated, and the phrases that negate one ("not deprecated", 非推奨ではな). */
+export type DeprecationWords = { readonly words: readonly string[]; readonly negated: readonly string[] };
+
+type Line = { readonly text: string; readonly start: number };
+type Marked = { readonly name: string; readonly offset: number };
+type Span = { readonly start: number; readonly end: number };
+type Found = { readonly at: number; readonly end: number };
+
+/** A name in code marks: `indent`, or the flag `--indent`, which is the name indent. */
+const CODE_SPAN = /`-{0,2}([A-Za-z_$][\w$-]*)`/gu;
+const FIRST_CELL_NAME = /`-{0,2}([A-Za-z_$][\w$-]*)`|^\s*-{0,2}([A-Za-z_$][\w$-]*)\s*$/u;
+const TABLE_ROW = /^[ \t]{0,3}\|/u;
+/** An anchor before a field name in a table cell: <a name="schemaExample"></a>example. */
+const HTML_TAG = /<[^<>]*>/gu;
+/** Where one statement ends: a sentence or a clause after a semicolon ("`indent` is deprecated; use `prefix`"). */
+const STATEMENT_END = /[.;。；!?！？]/u;
+/** A block that declares an API (interface Options { indent: number }) documents the name, and does not use it. */
+const DECLARATION_BLOCK = /^[ \t]*(?:export[ \t]+)?(?:interface|class|type[ \t]+[\w$]+[ \t]*=)/mu;
+
+const linesOf = (source: string): Line[] => {
+  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 insideOne = (spans: readonly Span[], offset: number): boolean => spans.some((span) => offset >= span.start && offset < span.end);
+
+const occurrences = (text: string, words: readonly string[]): Found[] => {
+  const lower = text.toLowerCase();
+  return words.flatMap((word) => {
+    const found: Found[] = [];
+    for (let at = lower.indexOf(word); at !== -1; at = lower.indexOf(word, at + word.length)) found.push({ at, end: at + word.length });
+    return found;
+  });
+};
+
+/** The deprecation words in a text, less those inside a negated phrase ("is not deprecated"). */
+const wordsIn = (text: string, words: DeprecationWords): Found[] => {
+  const negated = occurrences(text, words.negated);
+  return occurrences(text, words.words).filter((word) => !negated.some((phrase) => phrase.at <= word.at && word.end <= phrase.end));
+};
+
+/** Characters between a code span and the word: "`indent` を非推奨" is nearer than "非推奨にし、`prefix`". */
+const gap = (span: Found, word: Found): number => (span.end <= word.at ? word.at - span.end : span.at - word.end);
+
+/** A table row's first-cell name, and whether its later cells call it deprecated. */
+const rowOf = (line: Line, words: DeprecationWords): (Marked & { readonly deprecated: boolean }) | undefined => {
+  const cells = line.text.split("|");
+  const first = cells.findIndex((cell) => cell.trim() !== "");
+  if (first === -1) return undefined;
+  const name = FIRST_CELL_NAME.exec((cells[first] ?? "").replace(HTML_TAG, ""));
+  const written = name?.[1] ?? name?.[2];
+  const deprecated = wordsIn(cells.slice(first + 1).join("|"), words).length > 0;
+  return written === undefined ? undefined : { name: written, offset: line.start + line.text.indexOf(written), deprecated };
+};
+
+const markedInRow = (line: Line, words: DeprecationWords): Marked[] => {
+  const row = rowOf(line, words);
+  return row?.deprecated === true ? [{ name: row.name, offset: row.offset }] : [];
+};
+
+/**
+ * Names a table also lists without calling them deprecated: one page may describe two fields of one name, of which only
+ * one is deprecated (an example field of one object, and of another), and an example cannot tell which it uses.
+ */
+const listedAlive = (lines: readonly Line[], words: DeprecationWords): Set<string> =>
+  new Set(
+    lines.flatMap((line) => (line.text.includes("|") ? [rowOf(line, words)] : [])).flatMap((row) => (row === undefined || row.deprecated ? [] : [row.name])),
+  );
+
+/** In a statement, the code name nearest to each deprecation word: "`indent` is deprecated", "Deprecated: `indent`". */
+const markedInProse = (line: Line, words: DeprecationWords): Marked[] =>
+  wordsIn(line.text, words).flatMap((word) => {
+    const { at } = word;
+    const from = Math.max(...[...line.text.slice(0, at).matchAll(new RegExp(STATEMENT_END, "gu"))].map((match) => match.index + 1), 0);
+    const after = line.text.slice(at).search(STATEMENT_END);
+    const to = after === -1 ? line.text.length : at + after;
+    const spans = [...line.text.slice(from, to).matchAll(CODE_SPAN)].map((match) => ({
+      name: match[1] ?? "",
+      at: from + match.index,
+      end: from + match.index + match[0].length,
+    }));
+    const nearest = spans.toSorted((left, right) => gap(left, word) - gap(right, word))[0];
+    return nearest === undefined ? [] : [{ name: nearest.name, offset: line.start + line.text.indexOf(nearest.name, nearest.at) }];
+  });
+
+const escape = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/** A name used as an option in code: a key ({ indent: 2 }, "indent": 2), an argument (indent=2) or a flag (--indent). */
+const usePattern = (name: string): RegExp =>
+  new RegExp(`(?:(?<![\\w$.-])["']?${escape(name)}["']?[ \\t]*(?::(?!:)|=(?!=))|(?<![\\w-])--${escape(name)}(?![\\w-]))`, "u");
+
+const usesIn = (line: Line, marks: ReadonlyMap<string, number>): DeprecatedUse[] =>
+  [...marks].flatMap(([name, marked]) => {
+    const match = usePattern(name).exec(line.text);
+    return match === null ? [] : [{ name, offset: line.start + match.index + match[0].indexOf(name), marked }];
+  });
+
+/**
+ * The code lines that use a name the document calls deprecated. A code line that says so itself (`indent: 2 // deprecated`)
+ * shows the old use on purpose and is left out, and so is a block that declares an API rather than using it.
+ */
+export const deprecatedUses = (source: string, words: DeprecationWords): DeprecatedUse[] => {
+  if (words.words.length === 0) return [];
+  const fences = codeFences(source);
+  const lines = linesOf(source);
+  const prose = lines.filter((line) => !insideOne(fences, line.start));
+  const alive = listedAlive(prose, words);
+  const marked = prose
+    .flatMap((line) => (TABLE_ROW.test(line.text) ? markedInRow(line, words) : markedInProse(line, words)))
+    .filter((mark) => !alive.has(mark.name));
+  const firstMark = new Map(marked.toReversed().map((mark) => [mark.name, mark.offset]));
+  const examples = fences.filter((fence) => !DECLARATION_BLOCK.test(source.slice(fence.start, fence.end)));
+  return lines.filter((line) => insideOne(examples, line.start) && wordsIn(line.text, words).length === 0).flatMap((line) => usesIn(line, firstMark));
+};

package/src/derived/stays.ts

@@ -0,0 +1,145 @@
+import type { Span } from "../plugin.ts";
+import { bySentence } from "./sentence-buckets.ts";
+import { calendarDateOf, dateOf, shifted } from "./date-arithmetic.ts";
+import type { DatedValue } from "./durations.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+
+/**
+ * 泊数。チェックインからチェックアウトまでの泊数は、二つの日付の差の日数（10月12日から10月14日までは2泊）。
+ * 一つの文に日付がちょうど二つと泊数がちょうど一つあるときと、チェックイン・チェックアウト・泊数の列がそろった表の行で比べる。
+ * 「2泊3日」のように泊数と日数を並べたものは、日数が泊数より一つ多いかを見る。Pure.
+ */
+export type Count = Span & { readonly amount: number };
+
+export type NightsMismatch = { readonly start: DatedValue; readonly end: DatedValue; readonly nights: Span; readonly expected: number };
+
+export type NightsDaysMismatch = { readonly nights: Count; readonly days: Count; readonly expected: number };
+
+export type StayColumnWords = {
+  readonly checkIn: readonly string[];
+  readonly checkOut: readonly string[];
+  readonly nights: readonly string[];
+  /** The words of a nights unit (泊, nights) a nights cell may write after its number. */
+  readonly units: readonly string[];
+};
+
+const DAY_MS = 86_400_000;
+
+type Between = { start: DatedValue; end: DatedValue; nights: number };
+
+const daysFrom = (from: Date, to: Date): number => Math.round((to.getTime() - from.getTime()) / DAY_MS);
+
+/** 月日だけの二つの日付は、近いほうの向き（12月30日と1月2日は年をまたいで3泊、10月14日と10月12日は2泊）。 */
+const nearerWay = (first: DatedValue, second: DatedValue, firstDay: Date, secondDay: Date): Between => {
+  const forward = daysFrom(firstDay, secondDay);
+  const ahead = forward < 0 ? daysFrom(firstDay, shifted(secondDay, 1, "year")) : forward;
+  const back = -forward < 0 ? daysFrom(secondDay, shifted(firstDay, 1, "year")) : -forward;
+  return back < ahead ? { start: second, end: first, nights: back } : { start: first, end: second, nights: ahead };
+};
+
+/** 二つの日付の間の泊数。年まで書いたら早いほうから。年の有る日付と無い日付の組は読まない。 */
+const nightsBetween = (first: DatedValue, second: DatedValue): Between | undefined => {
+  const [firstDate, secondDate] = [calendarDateOf(first.value), calendarDateOf(second.value)];
+  if (firstDate === undefined || secondDate === undefined || (firstDate.year === undefined) !== (secondDate.year === undefined)) return undefined;
+  const [firstDay, secondDay] = [dateOf(firstDate), dateOf(secondDate)];
+  if (firstDate.year === undefined) return nearerWay(first, second, firstDay, secondDay);
+  const forward = daysFrom(firstDay, secondDay);
+  return forward < 0 ? { start: second, end: first, nights: -forward } : { start: first, end: second, nights: forward };
+};
+
+const mismatchOf = (first: DatedValue, second: DatedValue, nights: Count): NightsMismatch | undefined => {
+  const between = nightsBetween(first, second);
+  if (between === undefined || between.nights <= 0 || between.nights === nights.amount) return undefined;
+  return { start: between.start, end: between.end, nights, expected: between.nights };
+};
+
+/** 一つの文の中の、二つの日付と泊数。 */
+export const stayNightsMismatches = (sentences: readonly Span[], dates: readonly DatedValue[], nights: readonly Count[]): NightsMismatch[] => {
+  const datesIn = bySentence(sentences, dates);
+  return [...bySentence(sentences, nights).entries()].flatMap(([index, inNights]) => {
+    const inDates = datesIn.get(index) ?? [];
+    const [first, second] = inDates;
+    const [count] = inNights;
+    if (inDates.length !== 2 || inNights.length !== 1 || first === undefined || second === undefined || count === undefined) return [];
+    const mismatch = mismatchOf(first, second, count);
+    return mismatch === undefined ? [] : [mismatch];
+  });
+};
+
+const normalizedGap = (text: string): string => text.normalize("NFKC").trim().toLowerCase().replace(/\s+/gu, " ");
+
+const joined = (source: string, left: Span, right: Span, joiners: readonly string[]): boolean => {
+  if (right.start < left.end) return false;
+  const gap = normalizedGap(source.slice(left.end, right.start));
+  return gap === "" || joiners.some((joiner) => normalizedGap(joiner) === gap);
+};
+
+/** 泊数と日数を並べたもの（2泊3日、2 days, 1 night）。泊数の直前か直後に、つなぎの語だけを挟んで日数がある。 */
+export const nightsDaysPairs = (
+  source: string,
+  nights: readonly Count[],
+  days: readonly Count[],
+  joiners: readonly string[],
+): { nights: Count; days: Count }[] =>
+  nights.flatMap((count) => {
+    const paired = days.find((day) => joined(source, count, day, joiners) || joined(source, day, count, joiners));
+    return paired === undefined ? [] : [{ nights: count, days: paired }];
+  });
+
+/** 日数が泊数より一つ多くない組。 */
+export const nightsDaysMismatches = (pairs: readonly { nights: Count; days: Count }[]): NightsDaysMismatch[] =>
+  pairs.flatMap((pair) => (pair.days.amount === pair.nights.amount + 1 ? [] : [{ ...pair, expected: pair.nights.amount + 1 }]));
+
+const keyOf = (text: string): string => withoutEdgeMarks(text).normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+
+const columnOf = (header: readonly Cell[], names: readonly string[]): number => {
+  const wanted = new Set(names.map(keyOf));
+  return header.findIndex((cell) => wanted.has(keyOf(cell.text)));
+};
+
+const LEADING_DIGITS = /^\d+/u;
+
+/** 泊数の升の数（「2」「2泊」「2 nights」）。それ以外を書いた升は読まない。 */
+const nightsInCell = (cell: Cell, units: readonly string[]): Count | undefined => {
+  const key = keyOf(cell.text);
+  const digits = LEADING_DIGITS.exec(key)?.[0];
+  if (digits === undefined) return undefined;
+  const rest = key.slice(digits.length).trim();
+  if (rest !== "" && !units.some((unit) => keyOf(unit) === rest)) return undefined;
+  const offset = cell.text.length - cell.text.trimStart().length;
+  return { start: cell.start + offset, end: cell.end, amount: Number(digits) };
+};
+
+const onlyDateIn = (cell: Cell | undefined, dates: readonly DatedValue[]): DatedValue | undefined => {
+  if (cell === undefined) return undefined;
+  const inside = dates.filter((date) => date.start >= cell.start && date.end <= cell.end);
+  return inside.length === 1 ? inside[0] : undefined;
+};
+
+type StayColumns = { readonly checkIn: number; readonly checkOut: number; readonly nights: number };
+
+const rowMismatch = (cells: readonly Cell[], columns: StayColumns, dates: readonly DatedValue[], units: readonly string[]): NightsMismatch | undefined => {
+  const checkIn = onlyDateIn(cells[columns.checkIn], dates);
+  const checkOut = onlyDateIn(cells[columns.checkOut], dates);
+  const nightsCell = cells[columns.nights];
+  const nights = nightsCell === undefined ? undefined : nightsInCell(nightsCell, units);
+  return checkIn === undefined || checkOut === undefined || nights === undefined ? undefined : mismatchOf(checkIn, checkOut, nights);
+};
+
+/** チェックイン・チェックアウト・泊数の列がある表の、行ごとの泊数。 */
+export const tableNightsMismatches = (source: string, dates: readonly DatedValue[], words: StayColumnWords): NightsMismatch[] =>
+  tablesOf(linesOf(source)).flatMap(({ header, rows }) => {
+    const headerCells = cellsOf(header);
+    const columns = {
+      checkIn: columnOf(headerCells, words.checkIn),
+      checkOut: columnOf(headerCells, words.checkOut),
+      nights: columnOf(headerCells, words.nights),
+    };
+    if (Object.values(columns).some((index) => index < 0)) return [];
+    return rows.flatMap((row) => {
+      const mismatch = rowMismatch(cellsOf(row), columns, dates, words.units);
+      return mismatch === undefined ? [] : [mismatch];
+    });
+  });

package/src/detectors/acronym-context.ts

@@ -9,8 +9,8 @@ import { seriesLabelSpans } from "./series-label.ts";
 
 /**
  * 大文字の語が略語ではなく、決まった書き方の一部として読める所（3:30 PM、1pm ET、USD 1,000、Kansas City, MO 64108）。
- * どれも閉じた集合で、しかも隣の数字があるときだけ認める。PM（project manager）、CT、CA（certificate authority）は
- * 数字の隣でなければ略語のまま数える。語は言語パッケージの語彙表から読み、書き方の組み立てだけをここに置く。
+ * どれも閉じた集合で、しかも隣の数字（州は地名でもよい）があるときだけ認める。PM（project manager）、CT、CA（certificate authority）は
+ * その隣でなければ略語のまま数える。語は言語パッケージの語彙表から読み、書き方の組み立てだけをここに置く。
  */
 
 type Span = { readonly start: number; readonly end: number };
@@ -75,6 +75,13 @@ const titledName = (titles: string): readonly RegExp[] => [
   new RegExp(String.raw`(?<![\p{L}\p{N}_])${titles}\s+${SURNAME_IN_CAPITALS}${GIVEN_NAME_AFTER}`, "gu"),
 ];
 
+/**
+ * 郵便番号の無い所在地（Chicago, IL、Charleston, SC and…、Washington, DC: Association…）。頭が大文字の地名と読点の後ろで、
+ * 文や行の終わり・区切り・小文字の語が続くときだけ州と読む。数字や大文字の語が続くもの（Berkeley, CA 947、Sales, PA Team）は外さない。
+ */
+const placeAndState = (states: string): RegExp =>
+  new RegExp(String.raw`(?<=\p{Lu}\p{Ll}[\p{L}'’.-]*,\s+)${states}(?=[ \t]*(?:\r?\n|$)|[,.;:)\]!?]|\s+\p{Ll})`, "gu");
+
 // 強調の記号は空白に置き換えてある（**3:30** PM）ので、部品の間の空白は数を問わない。
 const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`${CLOCK_12}\s*${oneOf(words.meridiem)}`, "gu"),
@@ -82,6 +89,7 @@ const patternsOf = (words: NotationWords): readonly RegExp[] => [
   new RegExp(String.raw`${oneOf(words.currencies)}\s*[$€£¥]?${AMOUNT}`, "gu"),
   new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(words.currencies)}`, "gu"),
   new RegExp(String.raw`,\s+${oneOf(words.usStates)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
+  placeAndState(oneOf(words.usStates)),
   new RegExp(oneOf(words.emphasis), "gu"),
   ...numberedPatterns(words),
   new RegExp(String.raw`(?<![\p{L}\p{N}_])${oneOf(words.honorifics)}\s+${SURNAME_IN_CAPITALS}`, "gu"),

package/src/detectors/address-word.ts

@@ -0,0 +1,9 @@
+// Whether a word is part of an address or a file name rather than a word of the sentence. Pure.
+
+/** A word joined to a dot, an at sign or a slash is part of an address or a file name (github.com, user@example), spelled as it must be. */
+const ADDRESS_NEIGHBOUR = /[.@/\\_]/u;
+const WORD_CHAR = /\w/u;
+
+/** Whether text[start, end) is joined to an address mark before it, or to one followed by more of the address after it. */
+export const isPartOfAddress = (text: string, start: number, end: number): boolean =>
+  ADDRESS_NEIGHBOUR.test(text.charAt(start - 1)) || (ADDRESS_NEIGHBOUR.test(text.charAt(end)) && WORD_CHAR.test(text.charAt(end + 1)));

package/src/detectors/agreement-slip.ts

@@ -116,9 +116,15 @@ const mayBeNoun = (token: Token): boolean => token.features?.["AlsoNoun"] === "Y
 const mayBeVerb = (determiner: Determiner, modifiers: readonly Token[], noun: Token, next: Token | undefined, finite: ReadonlySet<string>): boolean =>
   noun.features?.["AlsoVerb"] === "Yes" && !(next !== undefined && finite.has(lower(next))) && (standsAlone(determiner) || modifiers.some(mayBeNoun));
 
+/** 冠詞は名詞句の頭に立つ。形容詞や数の後ろの a は、記号の名前（the eight 3-hourly a indices）。 */
+const AFTER_MODIFIER = new Set(["ADJ", "NUM"]);
+
+const isLetterName = (tokens: readonly Token[], at: number, determiner: Determiner): boolean =>
+  isArticle(determiner.head) && determiner.head.surface.length === 1 && AFTER_MODIFIER.has(tokens[at - 1]?.pos ?? "");
+
 const numberSlipAt = (source: string, tokens: readonly Token[], at: number, lists: AgreementLists): Slip | undefined => {
   const determiner = determinerAt(tokens, at, lists);
-  if (determiner === undefined || isNamePart(tokens, at)) return undefined;
+  if (determiner === undefined || isNamePart(tokens, at) || isLetterName(tokens, at, determiner)) return undefined;
   const modifiers = modifiersAfter(tokens, at + determiner.length, lists.count);
   if (modifiers === undefined || !readsAsDeterminer(determiner, modifiers)) return undefined;
   const nounAt = at + determiner.length + modifiers.length;

package/src/detectors/ai-phrasing.ts

@@ -5,6 +5,7 @@ import { entryIn, entryOpens } from "./lexicon-match.ts";
 import { contrastSentences, type ContrastWords } from "./contrast-frame.ts";
 import { placeholderSpans } from "./placeholder-text.ts";
 import { colonLeadIns } from "./list-lead-in.ts";
+import { followsInlineCode } from "./code-before.ts";
 
 // 生成文に多い形。語はどれも言語パッケージの語彙表が持ち、ここは形だけを知る。
 
@@ -68,8 +69,12 @@ export const openerDensity: Detector = (doc, options): Finding[] => densityFindi
  * 予告の文頭（重要なのは、Here's the thing）の数。limit は指摘に要る数。
  * 密度ではなく数で見る。人の記事も長さによらず 1 つ 2 つは書き、生成文は短い記事にも重ねる。
  */
+/** Where the sentence's first word starts: its span may begin with the blanks that masked code left. */
+const firstWordAt = (sentence: Sentence): number => sentence.span.start + sentence.text.length - sentence.text.trimStart().length;
+
 export const openerPile: Detector = (doc, options): Finding[] => {
-  const hits = openerHits(doc, options.lexicon ?? []);
+  // A sentence that opens with inline code (`explain` でも) opens with the code, not with the word after it.
+  const hits = openerHits(doc, options.lexicon ?? []).filter((hit) => !followsInlineCode(doc.source, doc.prose, firstWordAt(hit.sentence)));
   return hits.length === 0 || hits.length < options.limit ? [] : hits.map((hit) => findingOf(hit, { count: hits.length, limit: options.limit }));
 };
 

package/src/detectors/amount-range.ts

@@ -0,0 +1,54 @@
+// amount-range-reversed: a range of amounts whose upper end is below its lower end (structure/amount-range.ts). The amounts
+// are currency-notation's, read with amount-multiplier's words of scale and amount-short-scale's (k); the words of a range
+// are range-connector, range-opener, range-closer and amount-range-word; amount-change-word and amount-bound-label say
+// what makes a pair a change of price and what labels a bound.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { reversedAmountRanges, type AmountRangeWords, type RangeAmount } from "../structure/amount-range.ts";
+import type { ScaleWord } from "../structure/amount-scale.ts";
+import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
+import { AMOUNT, amountsIn, formsOf } from "./currency-notation.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+const shortScalesOf = (doc: ProseDocument): ScaleWord[] =>
+  (doc.lexicons["amount-short-scale"] ?? []).flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }]));
+
+const wordsOf = (doc: ProseDocument, scales: readonly ScaleWord[]): AmountRangeWords => ({
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+  openers: patternsOf(doc, "range-opener"),
+  closers: patternsOf(doc, "range-closer"),
+  changes: patternsOf(doc, "amount-change-word"),
+  lowers: patternsOf(doc, "amount-bound-label", "lower"),
+  uppers: patternsOf(doc, "amount-bound-label", "upper"),
+  links: patternsOf(doc, "amount-bound-label", "link"),
+  scales,
+  number: AMOUNT,
+});
+
+const rangeAmountsOf = (text: string, doc: ProseDocument, scales: readonly ScaleWord[]): RangeAmount[] =>
+  amountsIn(
+    text,
+    formsOf(doc),
+    scales.map((scale) => scale.word),
+  ).flatMap((amount) => {
+    const read = scaledAmountOf(text, amount, scales);
+    if (read === undefined) return [];
+    const position = amount.form.startsWith("before:") ? "before" : "after";
+    return [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit, position }];
+  });
+
+export const amountRange: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  const scales = [...scaleWordsOf(doc), ...shortScalesOf(doc)];
+  return reversedAmountRanges(text, rangeAmountsOf(text, doc, scales), wordsOf(doc, scales)).map((issue) => ({
+    rule: "amount-range-reversed",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};