chaffjs 0.17.0 → 0.19.0

package/src/detectors/gram-furniture.ts

@@ -0,0 +1,30 @@
+import type { Span } from "../plugin.ts";
+
+// ひな形が項目ごとに繰り返す飾り（一覧の札、リンクの文字、記号の並び）。書き手の言い回しではない。
+
+const MARK = /[\p{P}\p{S}]/gu;
+
+const BRACKETED = /[([{（［｛]([^()[\]{}（）［］｛｝]*)[)\]}）］｝]/gu;
+
+/** 札の 1 項目。空白を含まない 1 語で、平仮名も含まない（日本語で平仮名を含めば、括弧の中は言い回し）。 */
+const TAG_ITEM = /^\s*[^\s\p{Script=Hiragana}]+\s*$/u;
+
+/** 括弧の中が、1 語か 1 語ずつの並び（(replaced)、[pdf, html, other]）。(if applicable) のような句は札ではない。 */
+const isTag = (inside: string): boolean => inside.split(/[,、]/u).every((item) => TAG_ITEM.test(item));
+
+const spansOf = (text: string, pattern: RegExp, keep: (match: RegExpExecArray) => boolean): Span[] =>
+  [...text.matchAll(pattern)].filter(keep).map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** text の各位置（UTF-16 の単位）が飾りか。記号・句読点、括弧でくくった札、リンクの文字（linked が決める）。 */
+export const furnitureMask = (text: string, linked: (index: number) => boolean): boolean[] => {
+  const mask = Array.from({ length: text.length }, (_, index) => linked(index));
+  [...spansOf(text, MARK, () => true), ...spansOf(text, BRACKETED, (match) => isTag(match[1] ?? ""))].forEach((span) => mask.fill(true, span.start, span.end));
+  return mask;
+};
+
+/** 窓の中の空白でない文字の過半が飾りなら、その出現は飾り。 */
+export const isFurniture = (text: string, mask: readonly boolean[], window: Span): boolean => {
+  const visible = Array.from({ length: window.end - window.start }, (_, step) => window.start + step).filter((index) => !/\s/u.test(text[index] ?? ""));
+  const marked = visible.filter((index) => mask[index] === true);
+  return visible.length > 0 && marked.length * 2 > visible.length;
+};

package/src/detectors/gram-place.ts

@@ -37,12 +37,16 @@ export const compacted = (text: string, unit: LengthUnit): Compacted => {
   return { text: chars.join(""), offsets };
 };
 
+/** 詰めた文の中の範囲を、元の文の範囲に戻す。 */
+export const placeAt = (source: Compacted, window: Span): Span | undefined => {
+  const start = source.offsets[window.start];
+  const last = source.offsets[window.end - 1];
+  if (start === undefined || last === undefined) return undefined;
+  return { start, end: last + 1 };
+};
+
 /** 詰めた文の中の gram の最初の出現を、元の文の範囲に戻す。無ければ undefined。 */
 export const placeOf = (source: Compacted, gram: string): Span | undefined => {
   const at = source.text.indexOf(gram);
-  if (at === -1) return undefined;
-  const start = source.offsets[at];
-  const last = source.offsets[at + gram.length - 1];
-  if (start === undefined || last === undefined) return undefined;
-  return { start, end: last + 1 };
+  return at === -1 ? undefined : placeAt(source, { start: at, end: at + gram.length });
 };

package/src/detectors/gram-windows.ts

@@ -0,0 +1,31 @@
+import type { Span } from "../plugin.ts";
+
+/** 1 文字ずつずらした、幅 width の窓。 */
+export const charWindows = (text: string, width: number): Span[] =>
+  Array.from({ length: Math.max(0, text.length - width + 1) }, (_, start) => ({ start, end: start + width }));
+
+/** first 番目の語から数えて、minLength 文字に届く最初の語。届く前に尽きるのは minLength 文字に満たない末尾だけなので、深くならない。 */
+const reachingWord = (words: readonly Span[], first: number, minLength: number): Span | undefined => {
+  const start = words[first]?.start ?? 0;
+  const step = (index: number): Span | undefined => {
+    const word = words[index];
+    if (word === undefined || word.end - start >= minLength) return word;
+    return step(index + 1);
+  };
+  return step(first);
+};
+
+/** 語。前後の句読点と括弧は含めない。"described," と "described" を別の語句として数えないため。 */
+const WORD = /[\p{L}\p{N}](?:\S*[\p{L}\p{N}])?/gu;
+
+/**
+ * 語の頭で始まり語の尾で終わる窓。語を 1 つずつ足して、minLength 文字に届いた最短のもの。
+ * 文字で切ると " generat" や "roductivity change a" のような語の断片が数えられる。
+ */
+export const wordWindows = (text: string, minLength: number): Span[] => {
+  const words = [...text.matchAll(WORD)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+  return words.flatMap((first, index) => {
+    const last = reachingWord(words, index, minLength);
+    return last === undefined ? [] : [{ start: first.start, end: last.end }];
+  });
+};

package/src/detectors/hankaku-kana.ts

@@ -0,0 +1,38 @@
+import type { Detector, Finding, Span } from "../plugin.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+import { quoteAround } from "./quote-around.ts";
+
+/** 半角の片仮名と、半角の句読点・鉤括弧・中黒・長音・濁点（｡｢｣､･ｰﾞﾟ）。 */
+const HALFWIDTH_KANA_RUN = /[\uFF61-\uFF9F]+/gu;
+
+export type HalfwidthRun = { readonly span: Span; readonly written: string };
+
+/** 一行の中の、鉤括弧や引用符で引いたものの位置（行の頭を 0 とする）。引いた名前（「ｶﾅ表示」の画面名）は元の書き方のまま。 */
+const quotedOnLine = (source: string, at: number): { readonly lineStart: number; readonly quoted: readonly Span[] } => {
+  const lineStart = source.lastIndexOf("\n", at - 1) + 1;
+  const lineEnd = source.indexOf("\n", at);
+  return { lineStart, quoted: quotedSpans(source.slice(lineStart, lineEnd === -1 ? source.length : lineEnd), QUOTATION_MARKS) };
+};
+
+const isQuoted = (source: string, span: Span): boolean => {
+  const { lineStart, quoted } = quotedOnLine(source, span.start);
+  return isWithinAny(quoted, { start: span.start - lineStart, end: span.end - lineStart });
+};
+
+/** 字のまま見える範囲（texts）の中の、半角の片仮名の並び。引いたものの中は数えない。 */
+export const halfwidthKanaRuns = (source: string, texts: readonly Span[]): HalfwidthRun[] =>
+  texts.flatMap((text) =>
+    [...source.slice(text.start, text.end).matchAll(HALFWIDTH_KANA_RUN)]
+      .map((match) => ({ span: { start: text.start + match.index, end: text.start + match.index + match[0].length }, written: match[0] }))
+      .filter((run) => !isQuoted(source, run.span)),
+  );
+
+export const hankakuKana: Detector = (doc): Finding[] =>
+  halfwidthKanaRuns(doc.source, doc.markup?.texts ?? []).map(({ span, written }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(doc.source, span.start, span.end),
+    values: { kana: written, fullwidth: written.normalize("NFKC"), offset: span.start },
+  }));

package/src/detectors/heading-case.ts

@@ -1,7 +1,33 @@
+import { straightApostrophes } from "../orthography.ts";
+import { withoutCodeWords } from "./heading-code-words.ts";
+
+/** 語の中のアポストロフィは ' に畳んでから読む（Fed’s）。’ を語の外に置くと、’s が小文字の語に見える。 */
 const WORD = /[A-Za-z][A-Za-z'-]*/gu;
 
 /** 小さい語は Title Case でも小文字のままなので、大文字化の判定から外す。 */
-const MINOR = new Set(["a", "an", "the", "and", "or", "but", "of", "in", "on", "at", "to", "for", "with", "as", "by", "from", "is"]);
+export const MINOR_WORDS: ReadonlySet<string> = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "of",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "with",
+  "as",
+  "by",
+  "from",
+  "is",
+  // 語の並び（WORD）は点を含まないので、vs. と v. は vs と v で拾う。
+  "vs",
+  "v",
+  "via",
+]);
 
 /** 大文字だけの語（PR・FCPs）は略語で、どちらの流儀でも大文字のまま。Title Case の証拠にならない。 */
 const ACRONYM = /^[A-Z]{2,}s?$/u;
@@ -10,7 +36,9 @@ const TITLE_DEPTH = 1;
 
 /** 見出しが Title Case か。判定できなければ undefined。 */
 export const isTitleCase = (heading: string): boolean | undefined => {
-  const words = [...heading.matchAll(WORD)].map((match) => match[0]).filter((word) => !MINOR.has(word.toLowerCase()) && !ACRONYM.test(word));
+  const words = [...withoutCodeWords(straightApostrophes(heading)).matchAll(WORD)]
+    .map((match) => match[0])
+    .filter((word) => !MINOR_WORDS.has(word.toLowerCase()) && !ACRONYM.test(word));
   // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
   if (words.length < 2) return undefined;
   const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;

package/src/detectors/heading-code-words.ts

@@ -0,0 +1,35 @@
+// A code span closes at the next run of exactly as many backticks as opened it: ``a ` b`` is one span.
+const CODE_SPAN = /(?<!`)(`+)(?!`)[\s\S]*?(?<!`)\1(?!`)/gu;
+
+const OPENING = new Set("(\"'“‘[");
+const CLOSING = new Set(")\"'”’].,:;!?");
+
+/** The word without the punctuation around it: `(optional)` is `optional`, `Setup:` is `Setup`. */
+const bareWord = (token: string): string => {
+  const chars = [...token];
+  const first = chars.findIndex((char) => !OPENING.has(char));
+  const last = chars.findLastIndex((char) => !CLOSING.has(char));
+  return first === -1 || last < first ? "" : chars.slice(first, last + 1).join("");
+};
+
+/** A mark a word of prose does not carry inside it: `config.yaml`, `snake_case`, `src/index`, `useEffect()`, `$HOME`. */
+const CODE_MARK = /[._/\\=(){}[\]<>$@#*]/u;
+
+/** A word that starts in lower case and has a capital after it (`useEffect`, `iPhone`): its case is its owner's. */
+const CAMEL_CASE = /^[a-z]+[A-Z]/u;
+
+const isCodeWord = (token: string): boolean => {
+  const bare = bareWord(token);
+  return bare.startsWith("-") || CAMEL_CASE.test(bare) || CODE_MARK.test(bare);
+};
+
+/**
+ * The heading without its code words: a code span, a flag (`--force`), a file name (`config.yaml`), an identifier
+ * (`useEffect`). They are written the same in Title Case and in sentence case, so they are evidence for neither.
+ */
+export const withoutCodeWords = (heading: string): string =>
+  heading
+    .replace(CODE_SPAN, " ")
+    .split(/\s+/u)
+    .filter((token) => !isCodeWord(token))
+    .join(" ");

package/src/detectors/heading-echo.ts

@@ -1,6 +1,7 @@
 import { lengthOf, proseText } from "../measure.ts";
 import { newContentMorphemes } from "./content-morphemes.ts";
 import { echoedHeadingUnits, trigrams } from "./heading-overlap.ts";
+import { titleTokens } from "../heading-label.ts";
 import { handsOver } from "./lead-in.ts";
 import { withoutQuotedVariants } from "./quoted-variant.ts";
 import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
@@ -37,12 +38,15 @@ const NEW_MATERIAL = { word: 6, char: 20 };
  */
 const NEW_CONTENT_MORPHEMES = 1;
 
+/** 重なりを測る見出し。頭の番号の札（例 3：、Step 3:、1.）は本文で繰り返されないので、数えると短い見出しほど重なりが下がる。 */
+const measuredHeading = (section: Section): string => section.unlabeledHeading ?? section.heading;
+
 const addsLittle = (section: Section, unit: LengthUnit): boolean => {
   const first = section.firstSentence;
   if (first === undefined) return false;
   if (unit === "char" && first.tokens !== undefined && section.headingTokens !== undefined)
-    return newContentMorphemes(section.headingTokens, first.tokens) <= NEW_CONTENT_MORPHEMES;
-  return lengthOf(first, unit) - echoedHeadingUnits(section.heading, proseText(first), unit) <= NEW_MATERIAL[unit];
+    return newContentMorphemes(titleTokens(section.heading, measuredHeading(section), section.headingTokens), first.tokens) <= NEW_CONTENT_MORPHEMES;
+  return lengthOf(first, unit) - echoedHeadingUnits(measuredHeading(section), proseText(first), unit) <= NEW_MATERIAL[unit];
 };
 
 /** 最初の文が、同じ節の後ろ（箇条書き・表・コード）へ読者を渡している。 */
@@ -52,14 +56,14 @@ const leadsIn = (doc: ProseDocument, section: Section, phrases: readonly string[
 };
 
 /** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
-const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", section.heading);
+const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", measuredHeading(section));
 
 export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
   return doc.sections
     .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
     .filter((section) => !leadsIn(doc, section, leadIns))
-    .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(echoedText(section))) * 100) }))
+    .map((section) => ({ section, overlap: Math.round(containment(trigrams(measuredHeading(section)), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({
       rule: "heading-echo",

package/src/detectors/heading-level-skip.ts

@@ -0,0 +1,19 @@
+import type { Detector, Finding, MarkupHeading } from "../plugin.ts";
+import { findingAt, markupOf } from "./markup-finding.ts";
+
+export type SkippedHeading = { readonly heading: MarkupHeading; readonly from: number };
+
+/**
+ * 一つ前の見出しより二段以上深い見出し（## の次の ####）。最初の見出しは何段から始めてもよい。
+ * 飛んだ後は、飛んだ先の深さを基準にする（#### の次の #### は飛んでいない）。markdownlint の MD001 と同じ数え方。
+ */
+export const skippedHeadings = (headings: readonly MarkupHeading[]): SkippedHeading[] =>
+  headings.flatMap((heading, index) => {
+    const previous = headings[index - 1];
+    return previous !== undefined && heading.depth > previous.depth + 1 ? [{ heading, from: previous.depth }] : [];
+  });
+
+export const headingLevelSkip: Detector = (doc): Finding[] =>
+  skippedHeadings(markupOf(doc)?.headings ?? []).map(({ heading, from }) =>
+    findingAt(doc, heading, { heading: heading.text, from, to: heading.depth, expected: from + 1 }),
+  );

package/src/detectors/image-alt-text.ts

@@ -0,0 +1,11 @@
+import type { Detector, Finding, MarkupImage } from "../plugin.ts";
+import { findingAt, markupOf, quoteOf } from "./markup-finding.ts";
+
+/** 代替テキストの無い画像。Markdown の `![](a.png)` は alt が空、HTML の `<img>` は alt 属性が無いもの。`alt=""` は飾りと明示したので数えない。 */
+const lacksAlt = (source: string, image: MarkupImage): boolean => {
+  if (image.alt === undefined) return true;
+  return image.alt.trim() === "" && !source.startsWith("<", image.start);
+};
+
+export const imageAltText: Detector = (doc): Finding[] =>
+  (markupOf(doc)?.images ?? []).filter((image) => lacksAlt(doc.source, image)).map((image) => findingAt(doc, image, { image: quoteOf(doc.source, image) }));

package/src/detectors/index.ts

@@ -17,9 +17,47 @@ import { paragraphLength, paragraphVariance, preambleLength, ruleOfThree, sectio
 import { concreteEvidence, dashDensity, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
 import { aiTell, contractionMix, cushionDensity, hedging, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
 import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
+import { nameVariant } from "./name-variant.ts";
 import { latinSpacing, preferredTerm } from "./orthography.ts";
 import { straySpace } from "./stray-space.ts";
-import { danglingReference, dateOrder, dateWeekdayMismatch, duplicateDefinition, numberingGap, totalMismatch } from "./structure-tree.ts";
+import { announcedCount } from "./announced-count.ts";
+import { outsideAnnouncedList } from "./outside-announced-list.ts";
+import { danglingFigure } from "./dangling-figure.ts";
+import { nominalization } from "./nominalization.ts";
+import { requirementSmell } from "./requirement-smell.ts";
+import { requirementModal } from "./requirement-modal.ts";
+import { modalConflict } from "./modal-conflict.ts";
+import { vagueFigurePointer } from "./vague-figure-pointer.ts";
+import {
+  danglingReference,
+  dateOrder,
+  dateRangeReversed,
+  dateWeekdayMismatch,
+  duplicateDefinition,
+  numberingGap,
+  percentSumMismatch,
+  totalMismatch,
+} from "./structure-tree.ts";
+import { headingLevelSkip } from "./heading-level-skip.ts";
+import { imageAltText } from "./image-alt-text.ts";
+import { brokenLink } from "./broken-link.ts";
+import { urlRunOn } from "./url-run-on.ts";
+import { unbalancedBracket } from "./unbalanced-bracket.ts";
+import { doubledPunctuation } from "./doubled-punctuation.ts";
+import { kutotenConsistency } from "./kutoten-consistency.ts";
+import { hankakuKana } from "./hankaku-kana.ts";
+import { invisibleCharacter } from "./invisible-character.ts";
+import { spaceBeforePunctuation } from "./space-before-punctuation.ts";
+import { duplicateHeading } from "./duplicate-heading.ts";
+import { emptySection } from "./empty-section.ts";
+import { fullwidthAlnum } from "./fullwidth-alnum.ts";
+import { spellingVariety } from "./spelling-variety.ts";
+import { raNuki } from "./ra-nuki.ts";
+import { katakanaLongVowel } from "./long-vowel.ts";
+import { customPattern, customTokens, customWords } from "./custom.ts";
+import { boldLabelList } from "./bold-label.ts";
+import { acronymExpansionConflict, unusedDefinition, useBeforeDefinition } from "./definition-use.ts";
+import { assistantResidue, colonLeadIn, contrastFraming, openerDensity, openerPile, unfilledPlaceholder } from "./ai-phrasing.ts";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
 export const DETECTORS: Readonly<Record<string, Detector>> = {
@@ -58,17 +96,57 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "unqualified-superlative": unqualifiedSuperlative,
   "repeated-conjunction": repeatedConjunction,
   "ai-tell": aiTell,
+  "contrast-framing": contrastFraming,
+  "stock-transition": openerDensity,
+  "opener-pile": openerPile,
+  "colon-lead-in": colonLeadIn,
+  "assistant-residue": assistantResidue,
+  "unfilled-placeholder": unfilledPlaceholder,
   "contraction-mix": contractionMix,
   "internal-jargon": internalJargon,
   "required-sections": requiredSections,
   "proper-noun-density": properNounDensity,
+  "name-variant": nameVariant,
   "preferred-term": preferredTerm,
   "latin-spacing": latinSpacing,
   "stray-space": straySpace,
+  "katakana-long-vowel": katakanaLongVowel,
+  "custom-words": customWords,
+  "custom-pattern": customPattern,
+  "custom-tokens": customTokens,
   "dangling-reference": danglingReference,
   "date-weekday-mismatch": dateWeekdayMismatch,
   "date-order": dateOrder,
   "total-mismatch": totalMismatch,
   "numbering-gap": numberingGap,
   "duplicate-definition": duplicateDefinition,
+  "announced-count": announcedCount,
+  "outside-announced-list": outsideAnnouncedList,
+  "dangling-figure": danglingFigure,
+  nominalization: nominalization,
+  "requirement-smell": requirementSmell,
+  "requirement-modal": requirementModal,
+  "modal-conflict": modalConflict,
+  "vague-figure-pointer": vagueFigurePointer,
+  "date-range-reversed": dateRangeReversed,
+  "percent-sum-mismatch": percentSumMismatch,
+  "heading-level-skip": headingLevelSkip,
+  "image-alt-text": imageAltText,
+  "broken-link": brokenLink,
+  "url-run-on": urlRunOn,
+  "unbalanced-bracket": unbalancedBracket,
+  "doubled-punctuation": doubledPunctuation,
+  "kutoten-consistency": kutotenConsistency,
+  "hankaku-kana": hankakuKana,
+  "invisible-character": invisibleCharacter,
+  "space-before-punctuation": spaceBeforePunctuation,
+  "duplicate-heading": duplicateHeading,
+  "empty-section": emptySection,
+  "fullwidth-alnum": fullwidthAlnum,
+  "spelling-variety": spellingVariety,
+  "ra-nuki": raNuki,
+  "bold-label-list": boldLabelList,
+  "unused-definition": unusedDefinition,
+  "use-before-definition": useBeforeDefinition,
+  "acronym-expansion-conflict": acronymExpansionConflict,
 };

package/src/detectors/invisible-character.ts

@@ -0,0 +1,190 @@
+import type { Detector, Finding, Span } from "../plugin.ts";
+import { isJapanese } from "../orthography.ts";
+
+/**
+ * 見えない字の種類。zero-width はゼロ幅の空白・接合子と途中の BOM、soft-hyphen は任意の改行位置の印、direction は文字の向きの指定、
+ * control は改行・タブ・改ページ以外の制御文字、hidden は字の後ろに隠せる印（タグ文字、二つ以上続く異体字の指定）、
+ * nbsp は普通の空白が要る所のノーブレークスペース。どれも画面では見えず、検索・コピー・リンクを壊す。向きの指定と隠せる印は、
+ * 読み手に見えるものと機械が読むものを食い違わせるのにも使える。
+ */
+export type InvisibleKind = "zero-width" | "soft-hyphen" | "direction" | "control" | "hidden" | "nbsp";
+
+/**
+ * 種類ごとの字（正規表現の文字クラスの中身）。制御文字（Cc）には改行・タブ・改ページも入るので、それは isIntended が外す。
+ * hidden の異体字の指定は、字に一つ付いたものを isIntended が外す。
+ */
+const CLASSES: readonly (readonly [string, InvisibleKind])[] = [
+  ["\\u200B-\\u200D\\u2060-\\u2064\\uFEFF", "zero-width"],
+  ["\\u00AD", "soft-hyphen"],
+  ["\\u200E\\u200F\\u061C\\u202A-\\u202E\\u2066-\\u2069", "direction"],
+  ["\\p{Cc}", "control"],
+  ["\\u{E0001}\\u{E0020}-\\u{E007F}\\p{Variation_Selector}", "hidden"],
+  ["\\u00A0\\u2007\\u202F", "nbsp"],
+];
+
+const KIND_OF: readonly (readonly [RegExp, InvisibleKind])[] = CLASSES.map(([chars, kind]) => [new RegExp(`^[${chars}]$`, "u"), kind]);
+
+/** 一字ずつ当てる。タグ文字と異体字の指定は BMP の外にもあるので u で読む。 */
+const CANDIDATE = new RegExp(`[${CLASSES.map(([chars]) => chars).join("")}]`, "gu");
+
+const kindOf = (char: string): InvisibleKind | undefined => KIND_OF.find(([pattern]) => pattern.test(char))?.[1];
+
+/** 接合子（ZWJ・ZWNJ）で字の形を変える文字体系。アラビア文字やインドの文字では、見えない接合子が綴りの一部。 */
+const JOINING_SCRIPT = /[\p{L}\p{M}]/u;
+const NON_JOINING_SCRIPT = /[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+/** どの文字体系にも付くアクセント（U+0301 など）。ラテン文字の後ろの接合子を、接合子を使う文字体系のものと読まない。 */
+const INHERITED = /\p{Script=Inherited}/u;
+
+/** 右から左に書く文字。この字の隣の向きの印（LRM・RLM）は、英数字と混ぜて正しく並べるためのもの。 */
+const RIGHT_TO_LEFT = /[\p{Script=Hebrew}\p{Script=Arabic}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Nko}\p{Script=Samaritan}]/u;
+
+/** 字の向きを強制する印（LRO・RLO）。右から左の文字の隣でも、見える順を入れ替えるのに使えるので、いつも指摘する。 */
+const OVERRIDE = /[\u202D\u202E]/u;
+
+/** 絵文字の部品。ZWJ でつないだ絵文字（家族・職業）と、肌の色や異体字の指定を挟んだもの。 */
+const PICTOGRAPH = /[\p{Extended_Pictographic}\p{Emoji_Modifier}\uFE0F]/u;
+
+/** 黒い旗の絵文字。後ろにタグ文字を並べて地域の旗（イングランドなど）を書く。地域の名は六字までで、旗は字の数で十四単位に収まる。 */
+const BLACK_FLAG = String.fromCodePoint(0x1f3f4);
+const FLAG_REACH = 14;
+const TAG = /[\u{E0020}-\u{E007F}]/u;
+
+const VARIATION_SELECTOR = /\p{Variation_Selector}/u;
+
+/** 文書の形を作る制御文字（タブ・改行・改ページ）。 */
+const LAYOUT_CONTROL = /[\t\n\r\f]/u;
+
+/** Markdown の行の頭の印（見出し・箇条・番号・引用）。後ろの空白がノーブレークスペースだと、印として読まれない。 */
+const BLOCK_MARKER = /^[ \t]*(?:#{1,6}|[-*+]|\d{1,9}[.)]|>)$/u;
+const JAPANESE_MARK = /[、。「」『』（）・]/u;
+
+/** at の前の一字（サロゲートの対は一字に）。文書の頭なら空。 */
+const charBefore = (source: string, at: number): string => {
+  if (at <= 0) return "";
+  const low = source.charCodeAt(at - 1);
+  const isLow = low >= 0xdc00 && low <= 0xdfff;
+  return isLow && at >= 2 ? source.slice(at - 2, at) : source.slice(at - 1, at);
+};
+
+/** at から始まる一字。文書の終わりなら空。 */
+const charAt = (source: string, at: number): string => {
+  const code = source.codePointAt(at);
+  return code === undefined ? "" : String.fromCodePoint(code);
+};
+
+const isJoiningLetter = (char: string): boolean => JOINING_SCRIPT.test(char) && !NON_JOINING_SCRIPT.test(char) && !INHERITED.test(char);
+
+const isJapaneseSide = (char: string): boolean => isJapanese(char) || JAPANESE_MARK.test(char);
+
+const CANCEL_TAG = String.fromCodePoint(0xe007f);
+
+/** タグ文字の並びをさかのぼった先が黒い旗で、並びが取り消しのタグ（U+E007F）で閉じていれば、地域の旗の中。 */
+const isInFlag = (source: string, at: number): boolean => {
+  const before = [...source.slice(Math.max(0, at - FLAG_REACH), at)];
+  const after = [...source.slice(at, at + FLAG_REACH)];
+  const closing = after.findIndex((char) => !TAG.test(char) || char === CANCEL_TAG);
+  return before[before.findLastIndex((char) => !TAG.test(char))] === BLACK_FLAG && after[closing] === CANCEL_TAG;
+};
+
+/** 異体字の指定が付く字。空白や文書の頭の後ろの指定は、付く字が無い。 */
+const SELECTOR_BASE = /\S/u;
+
+/** 字が普通に使う異体字の指定は、字の後ろに一つ。二つ以上続く指定と、付く字の無い指定は、何かを隠した並び。 */
+const isLoneSelector = (source: string, at: number, length: number): boolean => {
+  const before = charBefore(source, at);
+  return SELECTOR_BASE.test(before) && !VARIATION_SELECTOR.test(before) && !VARIATION_SELECTOR.test(charAt(source, at + length));
+};
+
+/** 向きの分離の開き（LRI・RLI・FSI）と閉じ（PDI）。囲んだ中に右から左の文字があれば、混ぜて並べるための印。 */
+const ISOLATE_OPENS: readonly string[] = ["\u2066", "\u2067", "\u2068"];
+const ISOLATE_CLOSE = "\u2069";
+const ISOLATE_REACH = 200;
+
+/** 分離の印 char（at の位置）が囲む中身。組になる印が近くに無ければ undefined。 */
+const isolatedText = (source: string, at: number, char: string): string | undefined => {
+  if (ISOLATE_OPENS.includes(char)) {
+    const inside = source.slice(at + 1, at + 1 + ISOLATE_REACH);
+    const end = inside.indexOf(ISOLATE_CLOSE);
+    return end === -1 ? undefined : inside.slice(0, end);
+  }
+  if (char !== ISOLATE_CLOSE) return undefined;
+  const inside = source.slice(Math.max(0, at - ISOLATE_REACH), at);
+  const start = Math.max(...ISOLATE_OPENS.map((open) => inside.lastIndexOf(open)));
+  return start === -1 ? undefined : inside.slice(start + 1);
+};
+
+const isolatesRightToLeft = (source: string, at: number, char: string): boolean => RIGHT_TO_LEFT.test(isolatedText(source, at, char) ?? "");
+
+/** 文書の頭の BOM はファイルの印で、本文の字ではない。 */
+const BYTE_ORDER_MARK = "\uFEFF";
+
+const lineBefore = (source: string, at: number): string => source.slice(source.lastIndexOf("\n", at - 1) + 1, at);
+
+/** 見えない字一つと、その前後の字。 */
+type Place = { readonly source: string; readonly at: number; readonly char: string; readonly before: string; readonly after: string };
+
+const ZERO_WIDTH_JOINER = "\u200D";
+const ZERO_WIDTH_NON_JOINER = "\u200C";
+
+const joinsLetters = ({ before, after }: Place): boolean => isJoiningLetter(before) || isJoiningLetter(after);
+
+/** 種類ごとの、書き手が意味を持たせて置いた見えない字。そうでないものだけを指摘する。 */
+const INTENDED: Readonly<Record<InvisibleKind, (place: Place) => boolean>> = {
+  "zero-width": (place) => {
+    if (place.char === BYTE_ORDER_MARK) return place.at === 0;
+    if (place.char === ZERO_WIDTH_JOINER) return (PICTOGRAPH.test(place.before) && PICTOGRAPH.test(place.after)) || joinsLetters(place);
+    return place.char === ZERO_WIDTH_NON_JOINER && joinsLetters(place);
+  },
+  "soft-hyphen": () => false,
+  direction: ({ source, at, char, before, after }) =>
+    !OVERRIDE.test(char) && (RIGHT_TO_LEFT.test(before) || RIGHT_TO_LEFT.test(after) || isolatesRightToLeft(source, at, char)),
+  control: ({ char }) => LAYOUT_CONTROL.test(char),
+  hidden: ({ source, at, char }) => (TAG.test(char) ? isInFlag(source, at) : isLoneSelector(source, at, char.length)),
+  nbsp: ({ source, at, before, after }) => !BLOCK_MARKER.test(lineBefore(source, at)) && !isJapaneseSide(before) && !isJapaneseSide(after),
+};
+
+const isIntended = (source: string, at: number, char: string, kind: InvisibleKind): boolean =>
+  INTENDED[kind]({ source, at, char, before: charBefore(source, at), after: charAt(source, at + char.length) });
+
+export type InvisibleRun = { readonly span: Span; readonly kind: InvisibleKind; readonly codes: readonly string[] };
+
+export const codePointName = (char: string): string => `U+${(char.codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, "0")}`;
+
+const joinRuns = (runs: InvisibleRun[], next: InvisibleRun): InvisibleRun[] => {
+  const last = runs.at(-1);
+  if (last === undefined || last.span.end !== next.span.start || last.kind !== next.kind) return [...runs, next];
+  const codes = last.codes.includes(next.codes[0] ?? "") ? last.codes : [...last.codes, ...next.codes];
+  return [...runs.slice(0, -1), { span: { start: last.span.start, end: next.span.end }, kind: last.kind, codes }];
+};
+
+/** source の中の、見えない字の並び。隣り合う同じ種類の字は一つの並びにまとめる。 */
+export const invisibleRuns = (source: string): InvisibleRun[] =>
+  [...source.matchAll(CANDIDATE)]
+    .flatMap((match): InvisibleRun[] => {
+      const kind = kindOf(match[0]);
+      if (kind === undefined || isIntended(source, match.index, match[0], kind)) return [];
+      return [{ span: { start: match.index, end: match.index + match[0].length }, kind, codes: [codePointName(match[0])] }];
+    })
+    .reduce<InvisibleRun[]>(joinRuns, []);
+
+/** 見せる前後の字数。 */
+const QUOTE_REACH = 20;
+
+/** 見えない字を「⟨U+200B⟩」のように見える形にして、前後を引く。 */
+export const visibleQuote = (source: string, span: Span): string =>
+  source
+    .slice(Math.max(0, span.start - QUOTE_REACH), span.end + QUOTE_REACH)
+    .replace(CANDIDATE, (char) => (LAYOUT_CONTROL.test(char) ? char : `⟨${codePointName(char)}⟩`))
+    .replace(/\s+/gu, " ")
+    .trim();
+
+export const invisibleCharacter: Detector = (doc): Finding[] =>
+  invisibleRuns(doc.source).map((run) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: visibleQuote(doc.source, run.span),
+    values: { code: run.codes.join(" "), count: [...doc.source.slice(run.span.start, run.span.end)].length, offset: run.span.start },
+    variant: run.kind,
+  }));