chaffjs 0.29.0 → 0.30.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/structure/connection-times.ts

@@ -0,0 +1,226 @@
+import type { StructureIssue } from "./issues.ts";
+import { lineNumberAt, linesOf, type Line } from "./lines.ts";
+import { runsOf } from "./runs.ts";
+import type { Stop } from "./time-order.ts";
+import {
+  crossesZones,
+  dayShiftOf,
+  markBefore,
+  markSoonAfter,
+  wordOffsets,
+  zonesIn,
+  type DateSpan,
+  type Mark,
+  type TimeSpan,
+  type TimeWords,
+} from "./time-marks.ts";
+
+/**
+ * 乗り継ぎの間が、文書に書いた移動の時間より短い所。移動の時間は、移動の語（移動、徒歩、地下鉄、by Metro、coach。語彙表
+ * travel-time-word）と同じ文に書いた長さ（約10分、about 40 minutes）だけを使う。実際にかかる時間は推し量らない。
+ * 移動の始まりと終わりの時刻は二通りに読む。
+ * - 移動そのものを書いた予定（「10:00 京都駅から貸切バスで清水寺へ（約30分）」）は、その時刻に発ち、同じ日の次の予定までに着く。
+ * - 予定に添えた移動の時間（「09:55 博多駅で合流（福岡空港から地下鉄で約10分）」）や、時刻の無い移動の文に続けて書いた時刻は、
+ *   すぐ前の着の時刻（「福岡 09:50着」、表の到着の列）から移動して、その時刻に間に合う。
+ * 日付が違う、翌日の印がある、時刻が戻る（夜をまたぐ）、時間帯の印が違う所は比べない。
+ */
+
+/** 移動の時間として読む長さ。minutes は分。 */
+export type TravelLength = { readonly start: number; readonly end: number; readonly minutes: number };
+
+/** cues は移動を言う語、bounds は長さを上限として言う語（以内、within）。上限の長さは、それより早く着けるので使わない。 */
+export type TravelWords = { readonly cues: readonly Mark[]; readonly bounds: readonly Mark[] };
+
+export type ConnectionInputs = {
+  readonly source: string;
+  readonly times: readonly TimeSpan[];
+  readonly dates: readonly DateSpan[];
+  readonly words: TimeWords;
+  readonly travel: TravelWords;
+  readonly lengths: readonly TravelLength[];
+  readonly arrivals: ReadonlySet<number>;
+  readonly days: readonly (readonly Stop[])[];
+};
+
+const SECONDS_PER_MINUTE = 60;
+
+/** 文の切れ目。leg-times.ts と同じ。 */
+const BREAK = /[。．;；!?！？]|\.\s/gu;
+/** 括弧書き。中に括弧を入れ子にしたものは、内側から一つずつ外す。 */
+const BRACKETED = /[(（][^()（）]*[)）]/gu;
+/** 「within 10 minutes」の within と長さの間に挟んでよい字の数。 */
+const BOUND_GAP = 1;
+
+/** 発ってから着くまでの間が、書いた移動の時間より短いか。間が負なら（時刻が戻る）、夜をまたいだのか書き間違いか決められないので言わない。 */
+export const isTooShort = (gapSeconds: number, travelMinutes: number): boolean => gapSeconds >= 0 && gapSeconds < travelMinutes * SECONDS_PER_MINUTE;
+
+/** 二つの時刻に書いた日付が比べられるか。両方に無いか、同じ書き方で同じ日付なら同じ日。 */
+export const isSameDate = (left: string | undefined, right: string | undefined): boolean => left === right;
+
+/** 時間帯の印を見て、二つの行の時刻をそのまま比べられるか。どちらかが時間帯をまたぐか、印が違えば比べない。 */
+export const isSameZone = (left: string, right: string, words: TimeWords): boolean => {
+  const [leftZones, rightZones] = [zonesIn(left, words), zonesIn(right, words)];
+  if (crossesZones(leftZones) || crossesZones(rightZones)) return false;
+  return (leftZones[0]?.text ?? "") === (rightZones[0]?.text ?? "");
+};
+
+/** 括弧書きを外した残り。 */
+export const outsideBrackets = (text: string): string => {
+  const stripped = text.replace(BRACKETED, " ");
+  return stripped === text ? text : outsideBrackets(stripped);
+};
+
+/** text に移動の語が一語として書かれているか。大文字と小文字は区別しない。 */
+export const mentionsTravel = (text: string, cues: readonly Mark[]): boolean => {
+  const lower = text.toLowerCase();
+  return cues.some((cue) => wordOffsets(lower, cue.pattern.toLowerCase()).length > 0);
+};
+
+/** 行の中で、at から to までを含む文の範囲（行の頭からの位置）。 */
+export const sentenceAround = (text: string, at: number, to: number): { start: number; end: number } => {
+  const breaks = [...text.matchAll(BREAK)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+  const start = breaks.filter((cut) => cut.end <= at).at(-1)?.end ?? 0;
+  const end = breaks.find((cut) => cut.start >= to)?.start ?? text.length;
+  return { start, end };
+};
+
+const lineAt = (lines: readonly Line[], offset: number): Line | undefined => {
+  const number = lineNumberAt(lines, offset);
+  return number === undefined ? undefined : lines[number - 1];
+};
+
+/** 長さが上限として書かれている（10分以内、within 10 minutes）か。 */
+const isBound = (inputs: ConnectionInputs, line: Line, length: TravelLength): boolean => {
+  const head = inputs.source.slice(line.start, length.start).toLowerCase();
+  return markSoonAfter(inputs.source, length.end, inputs.travel.bounds, []) !== undefined || markBefore(head, inputs.travel.bounds, BOUND_GAP) !== undefined;
+};
+
+/** 移動の時間を書いた長さか。同じ文に移動の語があり、上限として書いたものではない。 */
+const isTravel = (inputs: ConnectionInputs, line: Line, length: TravelLength): boolean => {
+  const sentence = sentenceAround(line.text, length.start - line.start, length.end - line.start);
+  return mentionsTravel(line.text.slice(sentence.start, sentence.end), inputs.travel.cues) && !isBound(inputs, line, length);
+};
+
+/** 時刻の前の、同じ行に書いた最後の日付。 */
+const dateOf = (inputs: ConnectionInputs, line: Line, time: TimeSpan): string | undefined =>
+  inputs.dates.filter((date) => date.start >= line.start && date.end <= time.start).at(-1)?.value;
+
+const shiftOf = (inputs: ConnectionInputs, line: Line, time: TimeSpan): number =>
+  dayShiftOf(inputs.source.slice(line.start, time.start), inputs.source, time.end, inputs.words);
+
+const written = (inputs: ConnectionInputs, span: { start: number; end: number }): string => inputs.source.slice(span.start, span.end);
+
+type Leg = { readonly from: TimeSpan; readonly to: TimeSpan };
+
+const issueOf = (inputs: ConnectionInputs, leg: Leg, length: TravelLength): StructureIssue => ({
+  offset: leg.to.start,
+  values: {
+    time: written(inputs, leg.to),
+    from: written(inputs, leg.from),
+    gap: Math.round((leg.to.seconds - leg.from.seconds) / SECONDS_PER_MINUTE),
+    travel: written(inputs, length),
+  },
+});
+
+const dayOf = (inputs: ConnectionInputs, line: Line): readonly Stop[] | undefined =>
+  inputs.days.find((stops) => stops.some((stop) => stop.offset >= line.start && stop.offset <= line.start + line.text.length));
+
+const OPENERS = new Set(["(", "（"]);
+const CLOSERS = new Set([")", "）"]);
+
+/** at から to までを囲む一番内側の括弧の中身の範囲（行の頭からの位置）。囲む括弧が無ければ undefined。 */
+export const bracketAround = (text: string, at: number, to: number): { start: number; end: number } | undefined => {
+  const open = text
+    .slice(0, at)
+    .split("")
+    .reduceRight<{ depth: number; found: number | undefined }>(
+      (scan, char, index) => {
+        if (scan.found !== undefined) return scan;
+        if (CLOSERS.has(char)) return { ...scan, depth: scan.depth + 1 };
+        if (!OPENERS.has(char)) return scan;
+        return scan.depth === 0 ? { ...scan, found: index } : { ...scan, depth: scan.depth - 1 };
+      },
+      { depth: 0, found: undefined },
+    ).found;
+  if (open === undefined) return undefined;
+  const close = text
+    .slice(to)
+    .split("")
+    .findIndex((char) => CLOSERS.has(char));
+  return close === -1 ? undefined : { start: open + 1, end: to + close };
+};
+
+/**
+ * 移動そのものを書いた予定か。頭に時刻を書いた予定で、移動の語が括弧の外（行の本文）にある。長さを囲む括弧の中に移動の語が
+ * あれば（「（福岡空港から地下鉄で約10分）」）、その括弧はこの予定までの移動を添えたもので、予定は移動ではない。
+ */
+const isMoveLine = (inputs: ConnectionInputs, line: Line, length: TravelLength): boolean => {
+  const aside = bracketAround(line.text, length.start - line.start, length.end - line.start);
+  if (aside !== undefined && mentionsTravel(line.text.slice(aside.start, aside.end), inputs.travel.cues)) return false;
+  return dayOf(inputs, line) !== undefined && mentionsTravel(outsideBrackets(line.text), inputs.travel.cues);
+};
+
+/** 移動そのものを書いた予定の時刻と、同じ日の次の予定の時刻。 */
+const scheduledLeg = (inputs: ConnectionInputs, line: Line): Leg | undefined => {
+  const day = dayOf(inputs, line);
+  const index = day?.findIndex((stop) => stop.offset >= line.start) ?? -1;
+  const [start, next] = [day?.[index], day?.[index + 1]];
+  if (start === undefined || next === undefined || start.shift !== 0 || next.shift !== 0 || start.zone.startsWith("local:")) return undefined;
+  const timeAt = (offset: number): TimeSpan | undefined => inputs.times.find((time) => time.start === offset);
+  const [from, to] = [timeAt(start.offset), timeAt(next.offset)];
+  return from === undefined || to === undefined ? undefined : { from, to };
+};
+
+/** 時刻と同じ並び（続いた箇条書きや表の行）か同じ行にある、その時刻より前の時刻。 */
+const timesBeside = (inputs: ConnectionInputs, line: Line, to: TimeSpan): TimeSpan[] => {
+  const run = runsOf(inputs.source).find((lines) => lines.some((row) => row.start === line.start));
+  const inScope = (time: TimeSpan): boolean =>
+    (time.start >= line.start && time.end <= to.start) || (run?.some((row) => time.start >= row.start && time.end <= row.end) ?? false);
+  return inputs.times.filter((time) => time.end <= to.start && inScope(time));
+};
+
+/** 日付を書いた時刻なら、文書のそれより前の同じ日付の時刻。日付が無ければ、同じ並びか同じ行の、日付の無い前の時刻。 */
+const timesBefore = (inputs: ConnectionInputs, lines: readonly Line[], line: Line, to: TimeSpan): TimeSpan[] => {
+  const date = dateOf(inputs, line, to);
+  const candidates = date === undefined ? timesBeside(inputs, line, to) : inputs.times.filter((time) => time.end <= to.start);
+  return candidates.filter((time) => {
+    const own = lineAt(lines, time.start);
+    return own !== undefined && isSameDate(dateOf(inputs, own, time), date);
+  });
+};
+
+/**
+ * 移動の時間を添えた時刻。予定の行ならその頭の時刻、文なら移動の文の中かその後ろの、最初の着でない時刻。
+ * 移動の文より前の時刻は、移動の前の予定で、移動して着く先ではない。
+ */
+const arrivalTarget = (inputs: ConnectionInputs, line: Line, length: TravelLength): TimeSpan | undefined => {
+  const stop = dayOf(inputs, line)?.find((candidate) => candidate.offset >= line.start && candidate.offset <= line.start + line.text.length);
+  if (stop !== undefined) return inputs.times.find((time) => time.start === stop.offset);
+  const sentenceStart = line.start + sentenceAround(line.text, length.start - line.start, length.end - line.start).start;
+  return inputs.times.find((time) => time.start >= sentenceStart && time.end <= line.start + line.text.length && !inputs.arrivals.has(time.start));
+};
+
+/** 移動の時間を添えた時刻と、そのすぐ前の着の時刻。すぐ前の時刻が着でなければ、どこから移動したのか分からない。 */
+const arrivingLeg = (inputs: ConnectionInputs, lines: readonly Line[], line: Line, length: TravelLength): Leg | undefined => {
+  const to = arrivalTarget(inputs, line, length);
+  if (to === undefined) return undefined;
+  const from = timesBefore(inputs, lines, line, to).at(-1);
+  const fromLine = from === undefined ? undefined : lineAt(lines, from.start);
+  if (from === undefined || fromLine === undefined || !inputs.arrivals.has(from.start)) return undefined;
+  if (shiftOf(inputs, fromLine, from) !== 0 || shiftOf(inputs, line, to) !== 0 || !isSameZone(fromLine.text, line.text, inputs.words)) return undefined;
+  return { from, to };
+};
+
+/** 移動の時間を書いた長さごとに、間の足りない乗り継ぎ。同じ時刻は一度だけ言う。 */
+export const shortConnections = (inputs: ConnectionInputs): StructureIssue[] => {
+  const lines = linesOf(inputs.source);
+  const issues = inputs.lengths.flatMap((length) => {
+    const line = lineAt(lines, length.start);
+    if (line === undefined || !isTravel(inputs, line, length)) return [];
+    const leg = isMoveLine(inputs, line, length) ? scheduledLeg(inputs, line) : arrivingLeg(inputs, lines, line, length);
+    return leg !== undefined && isTooShort(leg.to.seconds - leg.from.seconds, length.minutes) ? [issueOf(inputs, leg, length)] : [];
+  });
+  return issues
+    .filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index)
+    .toSorted((left, right) => left.offset - right.offset);
+};