chaffjs 0.20.0 → 0.21.0

package/src/detectors/email-letter.ts

@@ -0,0 +1,262 @@
+// A work email or letter's own parts: a greeting and a closing, a subject line, and an attachment the text mentions.
+// Pure. The words (お世話になっております, Dear, Best regards, 件名, attached) come from the language's email-greeting,
+// email-closing, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
+// header and the signature are masked in doc.prose; a quoted reply is someone else's words and is left out.
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+
+/** A greeting comes before the body: past the subject, the addressee (株式会社… / 総務部 山田様) and the writer's name. */
+const GREETING_LINES = 5;
+/** A closing comes at the end, before the writer's name, title, company, address and contact lines, or an acceptance block. */
+const CLOSING_LINES = 10;
+
+/** One line of the writer's own text. breaks: a heading, the header or the signature stood between it and the line before. */
+export type BodyLine = { readonly start: number; readonly text: string; readonly breaks: boolean };
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const LATIN_START = /^[A-Za-z]/u;
+const LETTER = /\p{L}/u;
+
+/**
+ * Whether a line holds one of the words. A Latin word opens the line (Dear, Best regards) and is followed by no letter,
+ * so "Hi" does not match "History"; a Japanese word may stand anywhere in it (いつもお世話になっております).
+ */
+export const lineHas = (line: string, words: readonly string[]): boolean => {
+  const trimmed = line.trim();
+  const folded = trimmed.toLowerCase();
+  return words.some((word) => {
+    if (!LATIN_START.test(word)) return trimmed.includes(word);
+    return folded.startsWith(word.toLowerCase()) && !LETTER.test(trimmed.charAt(word.length));
+  });
+};
+
+/**
+ * Whether each offset, asked in rising order, is inside one of the spans (sorted by start). One pass over the spans for
+ * the whole document: an archive with a quoted reply in every message stays linear.
+ */
+const insideCursor = (spans: readonly Span[]): ((offset: number) => boolean) => {
+  const sorted = spans.toSorted((left, right) => left.start - right.start);
+  const cursor = { next: 0, farthestEnd: -1 };
+  return (offset) => {
+    while (cursor.next < sorted.length && (sorted[cursor.next]?.start ?? Infinity) <= offset) {
+      cursor.farthestEnd = Math.max(cursor.farthestEnd, sorted[cursor.next]?.end ?? 0);
+      cursor.next += 1;
+    }
+    return offset < cursor.farthestEnd;
+  };
+};
+
+/**
+ * A line prose masks words at the head of: a header field whose value stays (Subject: …), not the writer's text. Emphasis
+ * marks are masked too, but they hold no letter.
+ */
+const isFieldLine = (sourceLine: string, proseLine: string): boolean => {
+  const sourceChars = [...sourceLine];
+  const kept = [...proseLine].findIndex((char, index) => char.trim() !== "" || sourceChars[index]?.trim() === "");
+  return LETTER.test(sourceChars.slice(0, kept === -1 ? sourceChars.length : kept).join(""));
+};
+
+type SourceLine = { readonly start: number; readonly text: string };
+
+const linesWithOffsets = (text: string): SourceLine[] => {
+  const lines: SourceLine[] = [];
+  text.split("\n").forEach((line) => lines.push({ start: (lines.at(-1)?.start ?? 0) + (lines.at(-1)?.text.length ?? -1) + 1, text: line }));
+  return lines;
+};
+
+/**
+ * The writer's own lines, in order: not blank once the header and signature are masked (prose), not a quoted reply, not a
+ * heading. A heading, or a line the source has and prose masks (a header, a signature), breaks the text into parts.
+ */
+export const bodyLines = (source: string, prose: string, replyQuotes: readonly Span[]): BodyLine[] => {
+  const quoted = insideCursor(replyQuotes);
+  const lines: BodyLine[] = [];
+  const state = { broken: false };
+  linesWithOffsets(prose).forEach(({ start, text }) => {
+    const trimmed = text.trimStart();
+    const sourceLine = source.slice(start, start + text.length);
+    const masked = trimmed === "" ? sourceLine.trim() !== "" : isFieldLine(sourceLine, text);
+    const inQuote = quoted(start);
+    if (masked || trimmed.startsWith("#")) state.broken = true;
+    else if (trimmed !== "" && !trimmed.startsWith(">") && !inQuote) {
+      lines.push({ start, text, breaks: state.broken });
+      state.broken = false;
+    }
+  });
+  return lines;
+};
+
+/** The lines split where a heading, a header or a signature breaks them: a letter and its appendix, or one message and the next. */
+const partsOf = (lines: readonly BodyLine[]): BodyLine[][] => {
+  const parts: BodyLine[][] = [];
+  lines.forEach((line) => {
+    const current = parts.at(-1);
+    if (line.breaks || current === undefined) parts.push([line]);
+    else current.push(line);
+  });
+  return parts;
+};
+
+export type FrameSlip = { readonly variant: "greeting" | "closing"; readonly offset: number };
+
+/** A missing greeting (none in the first lines) and a missing closing (none in the last lines of any part). */
+export const frameSlips = (lines: readonly BodyLine[], greetings: readonly string[], closings: readonly string[]): FrameSlip[] => {
+  const first = lines[0];
+  const last = lines.at(-1);
+  if (first === undefined || last === undefined) return [];
+  const greeted = lines.slice(0, GREETING_LINES).some((line) => lineHas(line.text, greetings));
+  const closed = partsOf(lines).some((part) => part.slice(-CLOSING_LINES).some((line) => lineHas(line.text, closings)));
+  return [
+    ...(greeted ? [] : [{ variant: "greeting" as const, offset: first.start }]),
+    ...(closed ? [] : [{ variant: "closing" as const, offset: last.start }]),
+  ];
+};
+
+export const emailFrame: Detector = (doc): Finding[] =>
+  frameSlips(bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []), patternsOf(doc, "email-greeting"), patternsOf(doc, "email-closing")).map(
+    (slip) => ({
+      rule: "email-greeting-closing",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, slip.offset),
+      values: { offset: slip.offset },
+      variant: slip.variant,
+    }),
+  );
+
+export type SubjectLine = { readonly start: number; readonly subject: string };
+
+/** A field's name is one word of at most this many characters. */
+const MAX_FIELD_NAME = 20;
+const BLANK = /\s/u;
+
+/** "Subject: Lunch" as its name and value; undefined for a line that is no field. */
+export const fieldOf = (line: string): { readonly name: string; readonly value: string } | undefined => {
+  const colon = [...line].findIndex((char) => char === ":" || char === "：");
+  if (colon <= 0) return undefined;
+  const chars = [...line];
+  const name = chars.slice(0, colon).join("").trimEnd();
+  return name.length > MAX_FIELD_NAME || BLANK.test(name)
+    ? undefined
+    : {
+        name,
+        value: chars
+          .slice(colon + 1)
+          .join("")
+          .trim(),
+      };
+};
+
+/** The subject lines (Subject: …, 件名：…), outside a quoted reply, with reply and forward marks (Re:, Fwd:) taken off the value. */
+export const subjectLines = (source: string, fields: readonly string[], replyMarks: readonly string[], replyQuotes: readonly Span[]): SubjectLine[] => {
+  const names = new Set(fields.map((field) => field.toLowerCase()));
+  const quoted = insideCursor(replyQuotes);
+  return linesWithOffsets(source).flatMap(({ start, text }): SubjectLine[] => {
+    const field = fieldOf(text);
+    const inQuote = quoted(start);
+    return field === undefined || inQuote || !names.has(field.name.toLowerCase()) ? [] : [{ start, subject: withoutReplyMarks(field.value, replyMarks) }];
+  });
+};
+
+/** "Re: Fwd: Lunch" is "Lunch": the marks a mail program adds are not what the writer wrote. Read piece by piece between colons. */
+export const withoutReplyMarks = (subject: string, marks: readonly string[]): string => {
+  const folded = new Set(marks.map((mark) => mark.toLowerCase()));
+  const pieces = subject.split(/[:：]/u);
+  const kept = pieces.findIndex((piece, index) => index === pieces.length - 1 || !folded.has(piece.trim().toLowerCase()));
+  const dropped = pieces.slice(0, kept).reduce((length, piece) => length + piece.length + 1, 0);
+  return subject.slice(dropped).trim();
+};
+
+export const emailSubject: Detector = (doc, options): Finding[] =>
+  subjectLines(doc.source, patternsOf(doc, "email-subject-field"), patternsOf(doc, "email-reply-mark"), doc.replyQuotes ?? []).flatMap((line): Finding[] => {
+    const length = [...line.subject].length;
+    if (length > 0 && length <= options.limit) return [];
+    return [
+      {
+        rule: "email-subject-length",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, line.start),
+        values: { count: length, limit: options.limit, offset: line.start },
+        ...(length === 0 ? { variant: "empty" } : {}),
+      },
+    ];
+  });
+
+/** Where the text first mentions an attachment (添付します, attached), outside the phrases that only look like one (attached to). */
+export const firstMention = (lines: readonly BodyLine[], mentions: readonly string[], notMentions: readonly string[]): number | undefined => {
+  const folded = (text: string): string => text.toLowerCase();
+  const isMention = (text: string): boolean => {
+    const cleared = notMentions.reduce((rest, phrase) => rest.split(folded(phrase)).join(" "), folded(text));
+    return mentions.some((word) => cleared.includes(folded(word)));
+  };
+  const line = lines.find((candidate) => isMention(candidate.text));
+  return line === undefined ? undefined : line.start + line.text.length - line.text.trimStart().length;
+};
+
+/** The marks around a label line: a heading's #, emphasis, 【】. */
+const LINE_MARKS = new Set("#*_【】 \t\u3000");
+
+const withoutMarks = (line: string): string => {
+  const chars = [...line];
+  const first = chars.findIndex((char) => !LINE_MARKS.has(char));
+  return first === -1 ? "" : chars.slice(first, chars.findLastIndex((char) => !LINE_MARKS.has(char)) + 1).join("");
+};
+
+/** A line that labels what is attached: the label and a colon (Attachment: quote.pdf), or the label alone (### Enclosures, 【添付資料】). */
+const labelsAttachment = (line: string, labels: readonly string[]): boolean => {
+  const bare = withoutMarks(line).toLowerCase();
+  return labels.some((label) => {
+    const folded = label.toLowerCase();
+    return bare === folded || (bare.startsWith(folded) && /^\s*[:：]/u.test(bare.slice(folded.length)));
+  });
+};
+
+/** An attachment shown: a line that labels it, a file name with a listed extension, or the archive's note. text is the writer's own (no quoted reply). */
+export const showsAttachment = (text: string, labels: readonly string[], extensions: readonly string[], notes: readonly string[]): boolean => {
+  const labelled = text.split("\n").some((line) => labelsAttachment(line, labels));
+  const fileName = new RegExp(`[\\w\\-ぁ-んァ-ヶ一-龠]\\.(?:${extensions.map(escapeRegExp).join("|")})\\b`, "iu");
+  return labelled || (extensions.length > 0 && fileName.test(text)) || notes.some((note) => text.includes(note));
+};
+
+/** The source without someone else's words: a quoted reply's spans blanked and its "> " lines dropped. An old message's attachment is not this one's. */
+export const ownText = (source: string, replyQuotes: readonly Span[]): string => {
+  const pieces: string[] = [];
+  const cursor = { at: 0 };
+  replyQuotes
+    .toSorted((left, right) => left.start - right.start)
+    .forEach((span) => {
+      const from = Math.max(span.start, cursor.at);
+      pieces.push(source.slice(cursor.at, from), " ".repeat(Math.max(0, span.end - from)));
+      cursor.at = Math.max(cursor.at, span.end);
+    });
+  pieces.push(source.slice(cursor.at));
+  return pieces
+    .join("")
+    .split("\n")
+    .filter((line) => !line.trimStart().startsWith(">"))
+    .join("\n");
+};
+
+export const attachmentMissing: Detector = (doc): Finding[] => {
+  const lines = bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []);
+  const mention = firstMention(lines, patternsOf(doc, "attachment-mention"), patternsOf(doc, "attachment-not-mention"));
+  if (mention === undefined) return [];
+  const extensions = patternsOf(doc, "attachment-file-extension").map((extension) => extension.replace(/^\./u, ""));
+  if (showsAttachment(ownText(doc.source, doc.replyQuotes ?? []), patternsOf(doc, "attachment-line"), extensions, patternsOf(doc, "email-attachment-note")))
+    return [];
+  return [
+    {
+      rule: "attachment-not-attached",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, mention),
+      values: { offset: mention },
+    },
+  ];
+};

package/src/detectors/impossible-date.ts

@@ -0,0 +1,141 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 暦に無い日付（2月30日、4月31日、2023-02-29）。月の長さとうるう年は暦で決まるので、書き損じは機械で言える。
+// 月の名前は語彙表 month-name（初めの十二が一月から順に）、年月日の単位は date-time-unit（大きい順の初めの三つ）、元号は calendar-era が言う。
+
+/** 日付を読むのに要る語。months は一月から順の月の名前と略した名前、units は年・月・日の単位、eras は元号。 */
+export type CalendarWords = { readonly months: readonly string[]; readonly units: readonly string[]; readonly eras: readonly string[] };
+
+/** 暦に無い日付 1 つ。reason は、月が無い（month）、その月にその日が無い（day）、うるう年でない年の 2 月 29 日（leap）。 */
+export type ImpossibleDate = {
+  readonly offset: number;
+  readonly written: string;
+  readonly reason: "month" | "day" | "leap";
+  readonly month: number;
+  readonly days: number;
+};
+
+const DIGIT = "[0-9０-９]";
+const NOT_AFTER_NUMBER = "(?<![\\w/.\\-０-９])";
+/** 日付の後ろに来ない字。ただし日時（2023-02-29T10:00）の T は日付の終わり。 */
+const NOT_BEFORE_NUMBER = "(?:(?=T\\d)|(?![\\w/／\\-０-９]|\\.\\w))";
+const MONTHS_IN_YEAR = 12;
+const LONGEST_MONTH = 31;
+const FEBRUARY = 2;
+const LEAP_DAY = 29;
+const FIRST_CALENDAR_YEAR = 1000;
+const DAYS_IN_MONTH: readonly number[] = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const FULLWIDTH_OFFSET = 0xfee0;
+
+const halfWidth = (text: string): string => text.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+const isLeapYear = (year: number): boolean => (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+
+/** 書き方ごとの読み方。strict は数の組が日付だと単位や名前で分かる形で、月が 1〜12 にない・日が 31 を超えるのも言う。 */
+type Shape = { readonly pattern: RegExp; readonly strict: boolean };
+
+/** 年の数。元号の年や 4 桁でない年は、うるう年を決められないので undefined。 */
+const yearOf = (groups: Readonly<Record<string, string | undefined>>): number | undefined => {
+  const written = groups["y"];
+  if (written === undefined || groups["era"] !== undefined) return undefined;
+  const year = Number(halfWidth(written));
+  return year >= FIRST_CALENDAR_YEAR ? year : undefined;
+};
+
+/** 一月から順の月の名前（初めの十二）で、略した名前（Sept、Feb.）が何月か。 */
+const monthNamed = (months: readonly string[], written: string): number => {
+  const name = written.replace(/\.$/u, "");
+  return months.slice(0, MONTHS_IN_YEAR).findIndex((full) => full.startsWith(name)) + 1;
+};
+
+type Groups = Readonly<Record<string, string | undefined>>;
+
+const monthOf = (groups: Groups, months: readonly string[]): number =>
+  groups["name"] === undefined ? Number(halfWidth(groups["m"] ?? "")) : monthNamed(months, groups["name"]);
+
+/** その月の日数。2 月は、年が分かってうるう年でなければ 28 日、分からなければ 29 日。 */
+const daysIn = (month: number, year: number | undefined): number =>
+  month === FEBRUARY && year !== undefined && !isLeapYear(year) ? LEAP_DAY - 1 : (DAYS_IN_MONTH[month - 1] ?? LONGEST_MONTH);
+
+const problemOf = (month: number, day: number, year: number | undefined, strict: boolean): ImpossibleDate["reason"] | undefined => {
+  if (month < 1 || month > MONTHS_IN_YEAR) return strict ? "month" : undefined;
+  if (day < 1 || day > LONGEST_MONTH) return strict ? "day" : undefined;
+  if (day <= daysIn(month, year)) return undefined;
+  return month === FEBRUARY && day === LEAP_DAY ? "leap" : "day";
+};
+
+const shapesOf = (words: CalendarWords): Shape[] => {
+  const [yearUnit, monthUnit, dayUnit] = words.units.map(escapeRegExp);
+  const names = words.months.map(escapeRegExp).join("|");
+  const eras = words.eras.map(escapeRegExp).join("|");
+  const era = eras === "" ? "" : `(?:(?<era>${eras})\\s?)?`;
+  const unitShape =
+    yearUnit === undefined || monthUnit === undefined || dayUnit === undefined
+      ? []
+      : [
+          {
+            pattern: new RegExp(
+              `(?<!${DIGIT})${era}(?:(?<y>${DIGIT}{1,4}|元)${yearUnit}\\s?)?(?<m>${DIGIT}{1,2})${monthUnit}\\s?(?<d>${DIGIT}{1,2})${dayUnit}`,
+              "gu",
+            ),
+            strict: true,
+          },
+        ];
+  const nameShapes =
+    names === ""
+      ? []
+      : [
+          { pattern: new RegExp(`\\b(?<name>${names})\\.?\\s(?<d>\\d{1,2})(?:st|nd|rd|th)?(?![\\d:])(?:,?\\s(?<y>\\d{4})\\b)?`, "gu"), strict: false },
+          { pattern: new RegExp(`(?<![\\d.,])\\b(?<d>\\d{1,2})(?:st|nd|rd|th)?\\s(?<name>${names})\\b\\.?(?:,?\\s(?<y>\\d{4})\\b)?`, "gu"), strict: false },
+        ];
+  return [
+    { pattern: new RegExp(`${NOT_AFTER_NUMBER}(?<y>\\d{4})-(?<m>\\d{1,2})-(?<d>\\d{1,2})${NOT_BEFORE_NUMBER}`, "gu"), strict: false },
+    { pattern: new RegExp(`${NOT_AFTER_NUMBER}(?<y>\\d{4})[/／](?<m>\\d{1,2})[/／](?<d>\\d{1,2})${NOT_BEFORE_NUMBER}`, "gu"), strict: false },
+    ...unitShape,
+    ...nameShapes,
+  ];
+};
+
+const impossibleIn = (text: string, shape: Shape, months: readonly string[]): ImpossibleDate[] =>
+  [...text.matchAll(shape.pattern)].flatMap((match) => {
+    const groups = match.groups ?? {};
+    const month = monthOf(groups, months);
+    const year = yearOf(groups);
+    const reason = problemOf(month, Number(halfWidth(groups["d"] ?? "")), year, shape.strict);
+    if (reason === undefined) return [];
+    return [{ offset: match.index, written: match[0].trim(), reason, month, days: daysIn(month, year) }];
+  });
+
+/** 文字列の中の、暦に無い日付。同じ所に二つの形が当たれば、先に見つけたほうだけ。 */
+export const impossibleDates = (text: string, words: CalendarWords): ImpossibleDate[] => {
+  const byOffset = new Map<number, ImpossibleDate>();
+  shapesOf(words)
+    .flatMap((shape) => impossibleIn(text, shape, words.months))
+    .forEach((found) => {
+      if (!byOffset.has(found.offset)) byOffset.set(found.offset, found);
+    });
+  return [...byOffset.values()].toSorted((left, right) => left.offset - right.offset);
+};
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+export const calendarWordsOf = (doc: ProseDocument): CalendarWords => ({
+  months: patternsOf(doc, "month-name"),
+  units: patternsOf(doc, "date-time-unit").slice(0, 3),
+  eras: patternsOf(doc, "calendar-era"),
+});
+
+export const impossibleDate: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return impossibleDates(text, calendarWordsOf(doc)).map((found) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, found.offset, found.offset + found.written.length),
+    values: { written: found.written, month: found.month, days: found.days, offset: found.offset },
+    variant: found.reason,
+  }));
+};

package/src/detectors/impossible-time.ts

@@ -0,0 +1,151 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 時計に無い時刻（午後13時、13 PM、10:75、9時75分）。午前・午後が付けば時は 12 まで、分と秒は 59 まで。
+// 午前・午後の語とその置き場所は語彙表 clock-meridiem、時・分・秒の単位は date-time-unit（大きい順の四つ目から）が言う。
+// 午前・午後の無い「25:00」は、深夜の番組表のように 24 を超えて数える書き方があるので言わない。
+
+/** 時刻を読むのに要る語。before は時刻の前に書く午前・午後、after は後ろに書く AM・PM、units は時・分・秒の単位。 */
+export type ClockWords = { readonly before: readonly string[]; readonly after: readonly string[]; readonly units: readonly string[] };
+
+/** 時計に無い時刻 1 つ。reason は、午前・午後の付いた時が 12 を超える（hour）か、分か秒が 59 を超える（minute）か。 */
+export type ImpossibleTime = { readonly offset: number; readonly written: string; readonly reason: "hour" | "minute" };
+
+const DIGIT = "[0-9０-９]";
+const COLON = "[:：]";
+/** 数の前後に来ない字。英字の語や番号の中（abc10:75、v10:75）は時刻ではない。日本語の字のすぐ後ろ（会議は10:75）は読む。 */
+const NOT_AFTER_CLOCK = "(?<![A-Za-z0-9０-９_:：.])";
+const NOT_BEFORE_CLOCK = "(?![A-Za-z0-9０-９_:：])";
+const HALF_DAY = 12;
+const MINUTES_IN_HOUR = 60;
+/** 午前・午後の付いた時で、時刻の書き損じと読む上限。50 pm（ピコメートル）のような量を時刻と読まない。 */
+const HOURS_IN_DAY = 24;
+const FULLWIDTH_OFFSET = 0xfee0;
+
+const halfWidth = (text: string): string => text.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+type Groups = Readonly<Record<string, string | undefined>>;
+
+const numberIn = (groups: Groups, name: string): number | undefined => {
+  const written = groups[name];
+  return written === undefined ? undefined : Number(halfWidth(written));
+};
+
+/** 分か秒が 59 を超えるか。 */
+const isPastMinute = (groups: Groups): boolean =>
+  ["m", "colonMinute", "s"].some((name) => {
+    const value = numberIn(groups, name);
+    return value !== undefined && value >= MINUTES_IN_HOUR;
+  });
+
+/** 午前・午後の付いた時が 12 を超えるか（24 まで）。 */
+const isPastHalfDay = (groups: Groups): boolean => {
+  const hour = numberIn(groups, "h") ?? 0;
+  return hour > HALF_DAY && hour <= HOURS_IN_DAY;
+};
+
+/** 時刻の書き方と、その中の書き損じの見分け方。 */
+type Shape = { readonly pattern: RegExp; readonly problem: (groups: Groups, text: string, at: number) => ImpossibleTime["reason"] | undefined };
+
+const withMeridiem = (groups: Groups): ImpossibleTime["reason"] | undefined => {
+  if (isPastHalfDay(groups)) return "hour";
+  return isPastMinute(groups) ? "minute" : undefined;
+};
+
+const minutesOnly = (groups: Groups): ImpossibleTime["reason"] | undefined => (isPastMinute(groups) ? "minute" : undefined);
+
+/** 「Genesis 24:67」「Science, 12:75」のような章と節、巻と頁は時刻ではない。頭が大文字の語や区切りの印のすぐ後ろは読まない。 */
+const isCitationBefore = (before: string): boolean => {
+  const trimmed = before.trimEnd();
+  if ([",", ";", "."].includes(trimmed.slice(-1))) return true;
+  const lastWord = trimmed.split(/\s/u).at(-1) ?? "";
+  return /^\p{Lu}/u.test(lastWord);
+};
+
+/** 時を 2 以上か 0 埋め（09:75）で書いた、時と分だけの時刻。1:75 は縮尺や比。 */
+const bareClock = (groups: Groups, text: string, at: number): ImpossibleTime["reason"] | undefined => {
+  const hourText = groups["h"] ?? "";
+  const hour = Number(halfWidth(hourText));
+  const looksLikeClock = hour <= HOURS_IN_DAY && (hour >= 2 || /^[0０]/u.test(hourText));
+  if (!looksLikeClock || isCitationBefore(text.slice(Math.max(0, at - HALF_DAY), at))) return undefined;
+  return minutesOnly(groups);
+};
+
+const alternation = (words: readonly string[]): string => words.map(escapeRegExp).join("|");
+
+const meridiemShapes = (words: ClockWords): Shape[] => {
+  const [hourUnit, minuteUnit] = words.units.map(escapeRegExp);
+  const before = alternation(words.before);
+  const after = alternation(words.after);
+  const minuteTail = minuteUnit === undefined ? "" : `(?:\\s?(?<m>${DIGIT}{1,2})${minuteUnit})?`;
+  const unitTail = hourUnit === undefined ? "" : `${hourUnit}${minuteTail}|`;
+  return [
+    ...(after === ""
+      ? []
+      : [
+          {
+            pattern: new RegExp(`${NOT_AFTER_CLOCK}(?<![,])(?<h>${DIGIT}{1,2})(?:${COLON}(?<m>${DIGIT}{2}))?\\s?(?:${after})(?![\\p{L}\\p{N}])`, "gu"),
+            problem: withMeridiem,
+          },
+        ]),
+    ...(before === ""
+      ? []
+      : [{ pattern: new RegExp(`(?:${before})\\s?(?<h>${DIGIT}{1,2})(?:${unitTail}[:：](?<colonMinute>${DIGIT}{2}))`, "gu"), problem: withMeridiem }]),
+  ];
+};
+
+const unitShapes = (words: ClockWords): Shape[] => {
+  const [hourUnit, minuteUnit, secondUnit] = words.units.map(escapeRegExp);
+  if (hourUnit === undefined || minuteUnit === undefined) return [];
+  const seconds = secondUnit === undefined ? "" : `(?:\\s?(?<s>${DIGIT}{1,2})${secondUnit})?`;
+  return [{ pattern: new RegExp(`(?<!${DIGIT})(?<h>${DIGIT}{1,2})${hourUnit}\\s?(?<m>${DIGIT}{1,2})${minuteUnit}${seconds}`, "gu"), problem: minutesOnly }];
+};
+
+const shapesOf = (words: ClockWords): Shape[] => [
+  ...meridiemShapes(words),
+  ...unitShapes(words),
+  {
+    pattern: new RegExp(`${NOT_AFTER_CLOCK}(?<h>${DIGIT}{1,3})${COLON}(?<m>${DIGIT}{2})${COLON}(?<s>${DIGIT}{2})${NOT_BEFORE_CLOCK}`, "gu"),
+    problem: minutesOnly,
+  },
+  { pattern: new RegExp(`${NOT_AFTER_CLOCK}(?<![,/])(?<h>${DIGIT}{1,2})${COLON}(?<m>${DIGIT}{2})${NOT_BEFORE_CLOCK}`, "gu"), problem: bareClock },
+];
+
+const impossibleIn = (text: string, shape: Shape): ImpossibleTime[] =>
+  [...text.matchAll(shape.pattern)].flatMap((match) => {
+    const reason = shape.problem(match.groups ?? {}, text, match.index);
+    return reason === undefined ? [] : [{ offset: match.index, written: match[0].trim(), reason }];
+  });
+
+const overlaps = (left: ImpossibleTime, right: ImpossibleTime): boolean =>
+  left.offset < right.offset + right.written.length && right.offset < left.offset + left.written.length;
+
+/** 文字列の中の、時計に無い時刻。重なる所に二つの形が当たれば、先の形（午前・午後の付いたもの）だけ。 */
+export const impossibleTimes = (text: string, words: ClockWords): ImpossibleTime[] =>
+  shapesOf(words)
+    .flatMap((shape) => impossibleIn(text, shape))
+    .reduce<ImpossibleTime[]>((kept, found) => (kept.some((earlier) => overlaps(earlier, found)) ? kept : [...kept, found]), [])
+    .toSorted((left, right) => left.offset - right.offset);
+
+const meridiemOf = (doc: ProseDocument, position: "before" | "after"): string[] =>
+  (doc.lexicons["clock-meridiem"] ?? []).filter((entry) => entry.position === position).map((entry) => entry.pattern);
+
+export const clockWordsOf = (doc: ProseDocument): ClockWords => ({
+  before: meridiemOf(doc, "before"),
+  after: meridiemOf(doc, "after"),
+  units: (doc.lexicons["date-time-unit"] ?? []).map((entry) => entry.pattern).slice(3),
+});
+
+export const impossibleTime: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return impossibleTimes(text, clockWordsOf(doc)).map((found) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, found.offset, found.offset + found.written.length),
+    values: { written: found.written, offset: found.offset },
+    variant: found.reason,
+  }));
+};

package/src/detectors/link-shape.ts

@@ -0,0 +1,70 @@
+import type { Detector, Finding, Markup, ProseDocument, Span } from "../plugin.ts";
+import { findingAt, markupOf, quoteOf } from "./markup-finding.ts";
+import { linkTextOf } from "../link-text.ts";
+import { bareUrls } from "../bare-url.ts";
+import { isFileNameAlt, isUrlText, mismatchedHost } from "../link-shape.ts";
+import { minorityWithin } from "../orthography.ts";
+import { readMarkdown, spansOfType } from "../markdown-read.ts";
+
+/** A bare URL is reported only while bare URLs are at most this share of the document's links; past it, bare is a style. */
+const BARE_SHARE_PERCENT = 25;
+
+/** The link text, or undefined for an autolink, a definition or a link whose text is itself an address. */
+const wordedText = (source: string, link: Span): string | undefined => {
+  const text = linkTextOf(source.slice(link.start, link.end));
+  return text === undefined || text.trim() === "" || isUrlText(text) ? undefined : text;
+};
+
+/** An inline link the reader clicks on words (`[text](url)`). A reference definition's span does not show the words used with it, so it is not counted. */
+const isWorded = (source: string, link: Span): boolean => wordedText(source, link) !== undefined;
+
+/** A link destination the parser gave up on (`[a](https://…/{{ page }})`, a space in it): what is left is a link, not a bare URL. */
+const FAILED_DESTINATION = "](";
+
+const inside = (span: Span, regions: readonly Span[]): boolean => regions.some((region) => span.start >= region.start && span.start < region.end);
+
+/**
+ * The bare URLs the reader sees as text (outside links, code and quotations). A URL in a table cell is a value the table lists
+ * (an example request, a field's content), not a link the prose points to, so tables are left out.
+ */
+const bareUrlSpans = (source: string, markup: Markup): Span[] => {
+  const tables = spansOfType(readMarkdown(source).root, "table");
+  return markup.texts.flatMap((text) =>
+    bareUrls(source.slice(text.start, text.end))
+      .map((url) => ({ start: text.start + url.start, end: text.start + url.end }))
+      .filter((url) => !source.startsWith(FAILED_DESTINATION, url.start - FAILED_DESTINATION.length) && !inside(url, tables)),
+  );
+};
+
+type Address = Span & { readonly bare: boolean };
+
+/**
+ * A URL written bare (`https://…`) in a document whose other links are words (`[the guide](https://…)`). Reported only when the
+ * document has at least `limit` worded links and the bare ones are the few; a document that writes its URLs bare throughout is not.
+ */
+export const bareUrlMix: Detector = (doc: ProseDocument, options): Finding[] => {
+  const markup = markupOf(doc);
+  if (markup === undefined) return [];
+  const worded: Address[] = markup.links.filter((link) => isWorded(doc.source, link)).map((link) => ({ ...link, bare: false }));
+  if (worded.length < options.limit) return [];
+  const bare: Address[] = bareUrlSpans(doc.source, markup).map((url) => ({ ...url, bare: true }));
+  return minorityWithin([...worded, ...bare], (address) => address.bare, BARE_SHARE_PERCENT)
+    .filter((address) => address.bare)
+    .map((address) => findingAt(doc, address, { url: quoteOf(doc.source, address), count: worded.length }));
+};
+
+/** A link whose text is an address on one host and whose destination is on another (`[https://a.example](https://b.example)`). */
+export const linkTextUrlMismatch: Detector = (doc): Finding[] =>
+  (markupOf(doc)?.links ?? []).flatMap((link) => {
+    const text = linkTextOf(doc.source.slice(link.start, link.end));
+    const hosts = text === undefined ? undefined : mismatchedHost(text, link.destination);
+    return hosts === undefined ? [] : [findingAt(doc, link, hosts)];
+  });
+
+/** An image whose alt text is its file's name (`IMG_1234.png`, `Screenshot 2026-04-01`). The name prefixes come from the lexicon. */
+export const imageFileNameAlt: Detector = (doc, options): Finding[] => {
+  const prefixes = (options.lexicon ?? []).map((entry) => entry.pattern);
+  return (markupOf(doc)?.images ?? []).flatMap((image) =>
+    image.alt !== undefined && isFileNameAlt(image.alt, prefixes) ? [findingAt(doc, image, { alt: image.alt.trim() })] : [],
+  );
+};