chaffjs 0.35.0 → 0.37.0

package/src/detectors/heading-record-rhythm.ts

@@ -0,0 +1,57 @@
+/** 見出しの言葉から括弧の添え書き（「事例（約款）」の「（約款）」）を除いた、記録の型としての言葉。 */
+export const recordLabelOf = (key: string): string => {
+  const stem = key.replace(/[（(][^（）()]*[）)]/gu, "").trim();
+  return stem === "" ? key : stem;
+};
+
+/** start から period 個の型がみな違うか。窓をずらしながら数えるので、一つの period で列全体を一度なめるだけ。 */
+const distinctWindows = (labels: readonly string[], period: number): boolean[] => {
+  const counts = new Map<string, number>();
+  const add = (label: string | undefined, by: number): void => {
+    if (label !== undefined) counts.set(label, (counts.get(label) ?? 0) + by);
+    if (label !== undefined && counts.get(label) === 0) counts.delete(label);
+  };
+  return labels.map((label, start) => {
+    if (start === 0) labels.slice(0, period).forEach((first) => add(first, 1));
+    else {
+      add(labels[start - 1], -1);
+      add(labels[start + period - 1], 1);
+    }
+    return start + period <= labels.length && counts.size === period;
+  });
+};
+
+/** 各位置までに、period 前と同じ型だった位置の数（累積）。 */
+const repeatCounts = (labels: readonly string[], period: number): number[] =>
+  labels.reduce<number[]>((sums, label, at) => {
+    sums.push((sums.at(-1) ?? 0) + (at >= period && labels[at - period] === label ? 1 : 0));
+    return sums;
+  }, []);
+
+/** period の組が二度続く窓 [start, start + 2 * period) を、覆う範囲の印として足す。 */
+const markRepeats = (labels: readonly string[], period: number, cover: number[]): void => {
+  const distinct = distinctWindows(labels, period);
+  const repeats = repeatCounts(labels, period);
+  const repeatsIn = (from: number, to: number): number => (repeats[to - 1] ?? 0) - (repeats[from - 1] ?? 0);
+  distinct.forEach((isDistinct, start) => {
+    const end = start + 2 * period;
+    if (!isDistinct || end > labels.length || repeatsIn(start + period, end) !== period) return;
+    cover[start] = (cover[start] ?? 0) + 1;
+    cover[end] = (cover[end] ?? 0) - 1;
+  });
+};
+
+/**
+ * 兄弟の見出しの型（recordLabelOf）の並びで、「二つ以上の違う型の組が、同じ順で二度続く」所にある見出しの印。
+ * 事例ごとに【相談事例】【アドバイス】、Question / Answer をくり返す FAQ の決まった見出しで、写し忘れの重複ではない。
+ * 組の長さごとに列を一度なめるので、見出しの数の二乗で済む。
+ */
+export const recordRhythmMask = (labels: readonly string[]): boolean[] => {
+  const cover = Array.from({ length: labels.length + 1 }, () => 0);
+  Array.from({ length: Math.max(0, Math.floor(labels.length / 2) - 1) }, (_, offset) => offset + 2).forEach((period) => markRepeats(labels, period, cover));
+  const depths = cover.reduce<number[]>((sums, change) => {
+    sums.push((sums.at(-1) ?? 0) + change);
+    return sums;
+  }, []);
+  return labels.map((_, at) => (depths[at] ?? 0) > 0);
+};

package/src/detectors/ime-residue.ts

@@ -6,15 +6,16 @@ import { quoteAround } from "./quote-around.ts";
 /** One stray letter, and where it is in the text. */
 export type StrayLetter = { readonly offset: number; readonly letter: string };
 
-// Hiragana or kanji before (after katakana a letter is a label: サイズm, プランb), kana after.
-const STRAY = /(?<=[\p{Script=Hiragana}\p{Script=Han}々])[a-z](?=[\p{Script=Hiragana}\p{Script=Katakana}ー])/gu;
+// Hiragana or kanji before (after katakana a letter is a label: サイズm, プランb), kana after. Only a consonant: romaji
+// input turns a vowel into kana at once, so a lone vowel is a word of its own (eラーニング, iモード), never a residue.
+const STRAY = /(?<=[\p{Script=Hiragana}\p{Script=Han}々])[b-df-hj-np-tv-z](?=[\p{Script=Hiragana}\p{Script=Katakana}ー])/gu;
 /** Marks that make the run around the letter a path, an address or an assignment (/docs/あaい, a=b). */
 const PATH_MARK = /[/\\=@#]/u;
 
 const runBefore = (text: string, offset: number): string => text.slice(0, offset).split(/\s/u).at(-1) ?? "";
 
 /**
- * One lower-case letter between Japanese: hiragana or kanji before, kana after. A letter followed by a particle names
+ * One lower-case consonant between Japanese: hiragana or kanji before, kana after. A letter followed by a particle names
  * something (変数xが, まずxを, をxで), so it is left alone; the particles come from the lexicon.
  */
 export const strayLettersIn = (text: string, particles: readonly string[]): StrayLetter[] =>

package/src/detectors/kanji-compound-slip.ts

@@ -0,0 +1,61 @@
+import type { Detector, Finding, ProseDocument, Token } from "../plugin.ts";
+import { compoundSlipsIn, type CompoundUse, type CompoundWord } from "../kanji-compound-slip.ts";
+
+// Collects the document's kanji runs, from sentences, headings and table cells, each with the words the analyser cut it
+// into, and hands them to compoundSlipsIn.
+
+const KANJI_RUN = /[\p{Script=Han}々]+/gu;
+
+/** The analyser's words over [offset, offset + run), by kanji index. A word without a reading is one the analyser does not know. */
+const wordsOver = (run: string, offset: number, tokens: readonly Token[]): CompoundWord[] | undefined => {
+  const chars = Array.from(run);
+  const starts = chars.map((_, index) => offset + chars.slice(0, index).join("").length);
+  const indexOf = (position: number): number => starts.findIndex((start) => start >= position);
+  const words = tokens
+    .filter((token) => token.span.start < offset + run.length && token.span.end > offset)
+    .map((token) => {
+      const start = Math.max(0, indexOf(token.span.start));
+      const endIndex = indexOf(token.span.end);
+      const crossesRun = token.span.start < offset || token.span.end > offset + run.length;
+      return { start, end: endIndex === -1 ? starts.length : endIndex, known: token.reading !== undefined, crossesRun };
+    });
+  const covered = starts.every((_, index) => words.some((word) => word.start <= index && index < word.end));
+  return covered ? words : undefined;
+};
+
+const usesIn = (text: string, base: number, tokens: readonly Token[]): CompoundUse[] =>
+  [...text.matchAll(KANJI_RUN)].map((match) => {
+    const offset = base + match.index;
+    return { compound: match[0], offset, words: wordsOver(match[0], offset, tokens) };
+  });
+
+const shifted = (tokens: readonly Token[], by: number): Token[] =>
+  tokens.map((token) => ({ ...token, span: { start: token.span.start + by, end: token.span.end + by } }));
+
+const headingUses = (doc: ProseDocument): CompoundUse[] =>
+  doc.sections
+    .filter((section) => section.depth > 0)
+    .flatMap((section) => {
+      // A section's span starts after its heading line; a heading written differently from the source falls back to that line's start.
+      const found = doc.source.lastIndexOf(section.heading, section.span.start);
+      const base = found === -1 ? doc.source.lastIndexOf("\n", section.span.start - 1) + 1 : found;
+      return usesIn(section.heading, base, shifted(section.headingTokens ?? [], base));
+    });
+
+const compoundUsesOf = (doc: ProseDocument): CompoundUse[] => [
+  ...doc.sentences.flatMap((sentence) => usesIn(sentence.text, sentence.span.start, sentence.tokens ?? [])),
+  ...headingUses(doc),
+  ...(doc.tableCells?.() ?? []).flatMap((cell) => usesIn(cell.text, cell.start, cell.tokens ?? [])),
+];
+
+export const kanjiCompoundSlip: Detector = (doc, options): Finding[] => {
+  const ignored = new Set((options.lexicon ?? []).flatMap((entry) => Array.from(entry.pattern)));
+  return compoundSlipsIn(compoundUsesOf(doc), ignored).map((slip) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: slip.written,
+    values: { written: slip.written, usual: slip.usual, count: slip.usualCount, offset: slip.offset },
+  }));
+};

package/src/detectors/kutoten-consistency.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { latinCompanyFormRegExp, latinCompanyFormSpans } from "../latin-company-form.ts";
 import { minorityOf } from "../orthography.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 
@@ -14,7 +15,9 @@ const MARKS = /[、，。．]/gu;
 
 const DIGIT = /[\d０-９]/u;
 
-/** 番号の印（行の頭や読点・空白・括弧の後ろの「１．」「２．」）。文の中の数の後ろの点（締切は10．）は文の終わり。 */
+/**
+ * 番号の印（行の頭や読点・空白・括弧の後ろの「１．」「２．」）。文の中の数の後ろの点（締切は10．）は文の終わり。
+ */
 const LIST_NUMBER = /(?:^|[\s、，,（(])[\d０-９]{1,3}$/u;
 const LIST_NUMBER_REACH = 4;
 
@@ -22,29 +25,105 @@ const LIST_NUMBER_REACH = 4;
 const LATIN_LABEL = /(?:^|[^A-Za-zＡ-Ｚａ-ｚ])[A-Za-zＡ-Ｚａ-ｚ]{1,2}$/u;
 const LATIN_LABEL_REACH = 3;
 
+/** 片仮名の印（イ．ロ．ハ．）。語彙表 item-number の 1 字の片仮名で、前が片仮名でないとき（データ．の タ は語の終わり）。 */
+const KATAKANA = /^[ァ-ヺー]$/u;
+
+/** 句読点として数えない印と名前。kana は片仮名の項目の印、companyForms は英字の会社の形（CO.，LTD.）。 */
+export type MarkExceptions = { readonly kana: ReadonlySet<string>; readonly companyForms: RegExp | undefined };
+
+/**
+ * 印の点の後ろには、同じ行に項目の本文が続く。行の終わりの点（対象はロ．、締切は（予定）10．）は句点。
+ * 文は「イ．」の点で割れることがあるので、文ではなく文書の行の続きを見る。
+ */
+const isFollowed = (source: string, offset: number): boolean => {
+  const lineEnd = source.indexOf("\n", offset);
+  return source.slice(offset + 1, lineEnd === -1 ? source.length : lineEnd).trim() !== "";
+};
+
+type Place = { readonly text: string; readonly at: number; readonly source: string; readonly offset: number };
+
+const isKanaLabel = ({ text, at, source, offset }: Place, kana: ReadonlySet<string>): boolean =>
+  kana.has(text.charAt(at - 1)) && !KATAKANA.test(text.charAt(at - 2)) && isFollowed(source, offset);
+
+/**
+ * 括弧の後ろの番号。注の印の後ろ（(注)２．）か、括弧で閉じた見出しの後ろの最初の番号（事項）１．）。数の後ろに本文が続くときだけ印と読む。
+ * 括弧で添えた語の後ろのほかの数（締切は（予定）10．）は文の終わり。
+ */
+const NOTE_NUMBER_LABEL = /[（(]注[）)][\d０-９]{1,3}$/u;
+const CLOSED_FIRST_NUMBER = /[。）)】］\]][1１]$/u;
+const NOTE_REACH = 6;
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const TRAILING_NUMBER = /[\d０-９]{1,3}$/u;
+const asNumber = (digits: string): number => Number(digits.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET)));
+
+const NUMBER_POINT = /(?<![\d０-９])([\d０-９]{1,3})[．.](?![\d０-９])/gu;
+
+/** numbers の中に、1 から順に last まで、この順で並ぶか。 */
+const countsUpTo = (numbers: readonly number[], last: number): boolean => numbers.reduce((next, number) => (number === next ? next + 1 : next), 1) > last;
+
+/**
+ * 行が改行を失って続いた注（…（注）１．…持株会２．株式分割…３．有償…）の番号。同じ行の前に「１．」から一つ前までの番号の点が
+ * 順に並び、後ろに本文が続く。文の中の数の後ろの句点（締切は10．次回は11．）は、前に「１．」からの並びが無い。
+ */
+const isNextInRun = ({ source, offset }: Place): boolean => {
+  const lineStart = source.lastIndexOf("\n", offset) + 1;
+  const before = source.slice(lineStart, offset);
+  const digits = TRAILING_NUMBER.exec(before)?.[0];
+  if (digits === undefined || !isFollowed(source, offset)) return false;
+  const earlier = [...before.slice(0, -digits.length).matchAll(NUMBER_POINT)].map((match) => asNumber(match[1] ?? ""));
+  const previous = asNumber(digits) - 1;
+  return previous > 0 && countsUpTo(earlier, previous);
+};
+
+/**
+ * 番号を指す点（「3．から5．までの規定」「（1）4．の改正」）。数の点の直後に、番号を受ける助詞が続く。文の終わりの点の後ろは
+ * 次の文の頭。一字の助詞は後ろが平仮名でないときだけ（「のちほど」は文の頭）。文の頭になる語の字（で、も、は、と）は入れない。
+ */
+const ITEM_REFERENCE_AFTER = /^(?:から|まで|及び|又は|並びに|[のをにへ](?![ぁ-ゖ]))/u;
+
+const isItemReference = ({ text, at }: Place): boolean => DIGIT.test(text.charAt(at - 1)) && ITEM_REFERENCE_AFTER.test(text.slice(at + 1));
+
 const isInsideNumber = (text: string, at: number): boolean => DIGIT.test(text.charAt(at - 1)) && DIGIT.test(text.charAt(at + 1));
 
-const isLabelPeriod = (text: string, at: number): boolean =>
-  LIST_NUMBER.test(text.slice(Math.max(0, at - LIST_NUMBER_REACH), at)) || LATIN_LABEL.test(text.slice(Math.max(0, at - LATIN_LABEL_REACH), at));
+const isLabelPeriod = (place: Place, kana: ReadonlySet<string>): boolean => {
+  const { text, at } = place;
+  const beforeNumber = text.slice(Math.max(0, at - LIST_NUMBER_REACH), at);
+  return (
+    isKanaLabel(place, kana) ||
+    ((NOTE_NUMBER_LABEL.test(text.slice(Math.max(0, at - NOTE_REACH), at)) || CLOSED_FIRST_NUMBER.test(beforeNumber)) &&
+      isFollowed(place.source, place.offset)) ||
+    isNextInRun(place) ||
+    isItemReference(place) ||
+    LIST_NUMBER.test(beforeNumber) ||
+    LATIN_LABEL.test(text.slice(Math.max(0, at - LATIN_LABEL_REACH), at))
+  );
+};
 
 /**
- * 句読点として数えない「，」「．」。数の中の桁の区切りと小数点（１，０００、３．５）、番号の印の点（１．はじめに、、２．確認）、
+ * 句読点として数えない「，」「．」。数の中の桁の区切りと小数点（１，０００、３．５）、番号の印の点（１．はじめに、、２．確認、イ．）、
  * 一、二文字の英字の印の後ろの点（Ｑ．、No．）は、日本語の文の区切りではない。
  */
-const isNotPunctuation = (text: string, at: number, mark: string): boolean => {
-  if (mark === "．") return isInsideNumber(text, at) || isLabelPeriod(text, at);
-  if (mark === "，") return isInsideNumber(text, at);
+const isNotPunctuation = (place: Place, mark: string, kana: ReadonlySet<string>): boolean => {
+  if (mark === "．") return isInsideNumber(place.text, place.at) || isLabelPeriod(place, kana);
+  if (mark === "，") return isInsideNumber(place.text, place.at);
   return false;
 };
 
 export type Mark = { readonly kind: Kind["id"]; readonly western: boolean; readonly mark: string; readonly offset: number };
 
-/** 文の中の句読点。鉤括弧で引いたものの中は、引いた元の書き方なので数えない。offset は文書の中の位置。 */
-export const marksIn = (sentence: Sentence): Mark[] => {
-  const quoted: readonly Span[] = quotedSpans(sentence.text);
+/**
+ * 文の中の句読点。鉤括弧で引いたものの中は引いた元の書き方、英字の会社の形（CO.，LTD.）の中は名前の一部なので数えない。
+ * offset は文書の中の位置。
+ */
+export const marksIn = (sentence: Sentence, source: string, exceptions: MarkExceptions): Mark[] => {
+  const skipped: readonly Span[] = [...quotedSpans(sentence.text), ...latinCompanyFormSpans(sentence.text, exceptions.companyForms)];
   return [...sentence.text.matchAll(MARKS)]
-    .filter((match) => !isNotPunctuation(sentence.text, match.index, match[0]))
-    .filter((match) => !isWithinAny(quoted, { start: match.index, end: match.index }))
+    .filter((match) => {
+      const place = { text: sentence.text, at: match.index, source, offset: sentence.span.start + match.index };
+      return !isNotPunctuation(place, match[0], exceptions.kana);
+    })
+    .filter((match) => !isWithinAny(skipped, { start: match.index, end: match.index }))
     .map((match) => {
       const western = match[0] === "，" || match[0] === "．";
       const kind = match[0] === "、" || match[0] === "，" ? "comma" : "period";
@@ -76,14 +155,23 @@ const findingOf = (sentence: Sentence, entry: Mark, kind: Kind, tally: Tally): F
   variant: entry.kind,
 });
 
+const exceptionsOf = (doc: ProseDocument): MarkExceptions => {
+  const patterns = (name: string): string[] => (doc.lexicons[name] ?? []).map((entry) => entry.pattern);
+  return {
+    kana: new Set(patterns("item-number").filter((pattern) => KATAKANA.test(pattern))),
+    companyForms: latinCompanyFormRegExp(patterns("company-form-latin")),
+  };
+};
+
 /**
  * 読点（、と，）と句点（。と．）を、それぞれ文書の中でどちらかにそろえているか。混ざっていれば少ないほうを指摘する。
  * latin-spacing と同じく、同数なら文書が先に使った書き方をその文書の書き方とする。
  */
 export const kutotenConsistency: Detector = (doc, options): Finding[] => {
+  const exceptions = exceptionsOf(doc);
   const located = doc.sentences
     .filter((sentence) => !isCitation(sentence, doc.source))
-    .flatMap((sentence) => marksIn(sentence).map((entry) => ({ sentence, entry })));
+    .flatMap((sentence) => marksIn(sentence, doc.source, exceptions).map((entry) => ({ sentence, entry })));
   return KINDS.flatMap((kind) => {
     const ofKind = located.filter(({ entry }) => entry.kind === kind.id);
     const minority = minorityOf(ofKind.map(({ entry }) => entry.western));

package/src/detectors/lexicon.ts

@@ -1,11 +1,12 @@
 import { joinWords } from "./word-list.ts";
 import { pairMinority } from "./contraction-minority.ts";
+import { withoutMentions } from "./contraction-mention.ts";
 import { straightApostrophes } from "../orthography.ts";
 import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { entryIn, entryOpens, entryRanges, type TokenRange } from "./lexicon-match.ts";
 import { scoped, scopeMarkersOf, type ScopeMarkers } from "./superlative-scope.ts";
-import { namesQuantity } from "./superlative-name.ts";
+import { makesWord, namesQuantity } from "./superlative-name.ts";
 import { namesAmount } from "./superlative-amount.ts";
 import { restricted, type Restrictors } from "./superlative-clause.ts";
 import { stackedHedges, type StackedHedge } from "./stacked-hedge.ts";
@@ -16,10 +17,19 @@ const PER = 1000;
 /** 密度を見る rule は短い文書を測らない。単位は言語で違うので床も分ける。 */
 const FLOOR = { word: 200, char: 500 };
 
-type Hit = { readonly sentence: Sentence; readonly matched: string };
+type Hit = { readonly sentence: Sentence; readonly matched: string; readonly group?: string | undefined };
 
 const hitsFor = (doc: ProseDocument, lexicon: Lexicon): Hit[] =>
-  doc.sentences.flatMap((sentence) => lexicon.filter((entry) => entryIn(sentence, entry)).map((entry) => ({ sentence, matched: entry.pattern })));
+  doc.sentences.flatMap((sentence) =>
+    lexicon.filter((entry) => entryIn(sentence, entry)).map((entry) => ({ sentence, matched: entry.pattern, group: entry.group })),
+  );
+
+/**
+ * A lexicon word in group address says how the document speaks to its reader (あなたの). Alone it is the writer's chosen
+ * register, so it counts only beside a phrase from outside the group.
+ */
+const ADDRESS_GROUP = "address";
+const onlyAddress = (hits: readonly Hit[]): boolean => hits.every((hit) => hit.group === ADDRESS_GROUP);
 
 /**
  * 床より短い文書の扱い。skip は測らない。at-floor は SHORT_LENGTH の長さの文書として測り、一つだけなら言わない（一つは礼儀）。
@@ -52,7 +62,7 @@ const densityRule =
     const hits = hitsFor(doc, options.lexicon ?? []);
     const length = wordsOf(doc);
     const isShort = length < FLOOR[doc.lengthUnit];
-    if (hits.length === 0 || (isShort && (short === "skip" || hits.length < SHORT_MINIMUM_HITS))) return [];
+    if (onlyAddress(hits) || (isShort && (short === "skip" || hits.length < SHORT_MINIMUM_HITS))) return [];
     if (perThousand(hits.length, isShort ? SHORT_LENGTH[doc.lengthUnit] : length) <= options.limit) return [];
     const density = perThousand(hits.length, length);
     return hits.map((hit) => ({
@@ -112,6 +122,7 @@ type Qualifiers = {
   readonly comparison: ComparisonMarkers;
   readonly scope: ScopeMarkers;
   readonly quantityNouns: Lexicon;
+  readonly suffixes: Lexicon;
   readonly amounts: Lexicon;
   readonly restrictors: Restrictors;
 };
@@ -120,6 +131,7 @@ const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
   comparison: comparisonMarkersOf(doc.lexicons["comparison-marker"] ?? []),
   scope: scopeMarkersOf(doc.lexicons["superlative-scope"] ?? []),
   quantityNouns: doc.lexicons["quantity-noun"] ?? [],
+  suffixes: doc.lexicons["superlative-suffix"] ?? [],
   amounts: doc.lexicons["superlative-amount"] ?? [],
   restrictors: {
     relatives: doc.lexicons["relative-word"] ?? [],
@@ -134,6 +146,7 @@ const qualifiedAt = (tokens: readonly Token[], range: TokenRange, qualifiers: Qu
   scoped(tokens, range, qualifiers.scope) ||
   restricted(tokens, range, qualifiers.restrictors) ||
   namesQuantity(tokens, range, qualifiers.quantityNouns) ||
+  makesWord(tokens, range, qualifiers.suffixes) ||
   namesAmount(tokens, range, qualifiers.amounts);
 
 /** どの出現も引いた言葉か、限られているか、量を言うときだけ。1 つでもそうでない出現があれば、その文には限定の無い最上級がある。 */
@@ -274,7 +287,7 @@ const containsWord = (text: string, word: string): boolean => wordUses(text, wor
  * アポストロフィの形（don’t と don't）は短縮形かどうかを変えない。違うのは印刷の形で、文体ではない。
  * 折り返した行（「do」で改行して「not」）も、空白 1 つと同じに読む。
  */
-const comparableText = (sentence: Sentence): string => straightApostrophes(sentence.text).replace(/\s+/gu, " ").toLowerCase();
+const comparableText = (sentence: Sentence): string => withoutMentions(straightApostrophes(sentence.text)).replace(/\s+/gu, " ").toLowerCase();
 
 type MixedPair = { readonly minority: string; readonly majority: string; readonly count: number };
 

package/src/detectors/link-shape.ts

@@ -2,7 +2,7 @@ import type { Detector, Finding, Markup, ProseDocument, Span } from "../plugin.t
 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 { isFieldValueUrl, isFileNameAlt, isUrlText, mismatchedHost } from "../link-shape.ts";
 import { minorityWithin } from "../orthography.ts";
 import { readMarkdown, spansOfType } from "../markdown-read.ts";
 
@@ -23,16 +23,23 @@ const FAILED_DESTINATION = "](";
 
 const inside = (span: Span, regions: readonly Span[]): boolean => regions.some((region) => span.start >= region.start && span.start < region.end);
 
+const isFieldValue = (source: string, url: Span): boolean => {
+  const lineStart = source.lastIndexOf("\n", url.start - 1) + 1;
+  const lineEnd = source.indexOf("\n", url.end);
+  return isFieldValueUrl(source.slice(lineStart, url.start), source.slice(url.end, lineEnd === -1 ? source.length : lineEnd));
+};
+
 /**
  * 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.
+ * (an example request, a field's content), not a link the prose points to, so tables are left out, and so is a field's value
+ * on its own line (`**Licence text** https://…`).
  */
 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)),
+      .filter((url) => !source.startsWith(FAILED_DESTINATION, url.start - FAILED_DESTINATION.length) && !inside(url, tables) && !isFieldValue(source, url)),
   );
 };
 

package/src/detectors/list-item-ending.ts

@@ -0,0 +1,51 @@
+// How a list item's last words are found: past the marks after them (!!, a footnote reference [^1]), which the tagger
+// may call nouns. Pure; reads tokens only.
+import type { Token } from "../plugin.ts";
+
+/** Only marks (!!, ?!, …), whatever tag the tagger gave them. */
+const MARKS_ONLY = /^[\p{P}\s]+$/u;
+
+/** The caret that opens a footnote reference: alone after its masked bracket, or with the bracket when no definition masks it ([^). */
+const CARET = /^\[?\^$/u;
+
+/** The blank a masked bracket leaves before the caret. */
+const BLANK = /^\s+$/u;
+
+/** A footnote label after the caret: [^1], [^note-2]. */
+const FOOTNOTE_LABEL = /^[\p{L}\p{N}_-]+$/u;
+
+/** A token that ends an item's look but is not one of its words. */
+export type IsMark = (token: Token) => boolean;
+
+/** A tag-skipped token, or one made only of marks. */
+export const markOrSkipped =
+  (skipped: ReadonlySet<string>): IsMark =>
+  (token) =>
+    skipped.has(token.pos) || MARKS_ONLY.test(token.surface);
+
+/**
+ * The tokens before a footnote reference at the end (…まだ先 [^1]). The caret must carry its bracket or follow the blank
+ * its masked bracket leaves, so x^2 and "x: ^2" keep their exponent.
+ */
+export const withoutFootnoteReference = (tokens: readonly Token[], isMark: IsMark): readonly Token[] => {
+  const caret = tokens.findLastIndex((token) => CARET.test(token.surface));
+  const opener = tokens[caret];
+  const before = tokens[caret - 1];
+  if (opener === undefined || !(opener.surface.startsWith("[") || (before !== undefined && BLANK.test(before.surface)))) return tokens;
+  const label = tokens.slice(caret + 1);
+  return label.every((token) => isMark(token) || FOOTNOTE_LABEL.test(token.surface)) ? tokens.slice(0, caret) : tokens;
+};
+
+/** The tokens up to the last word: the marks after it dropped. */
+export const withoutTrailingMarks = (tokens: readonly Token[], isMark: IsMark): readonly Token[] =>
+  tokens.slice(0, tokens.findLastIndex((token) => !isMark(token)) + 1);
+
+/**
+ * A noun with あり or なし right after it (翻訳あり, 駐車場なし): a headline's "with" or "without", not a predicate. A
+ * particle between them (翻訳があり) makes it a clause. `endings` holds the words, from the word list headline-ending.
+ */
+export const endsAsHeadline = (words: readonly Token[], endings: ReadonlySet<string>): boolean => {
+  const last = words.at(-1);
+  const before = words.at(-2);
+  return last !== undefined && endings.has(last.surface) && (before?.pos === "NOUN" || before?.pos === "PROPN");
+};