hanlint 0.0.1

package/src/fingerprint/build.js

@@ -0,0 +1,284 @@
+// @ts-check
+/** 문서 모델을 한 번 훑어 글 지문을 만든다. 텍스트를 읽는 유일한 자리다. 파이썬 fingerprint/build.py 와 같다. */
+import { defaultConfig } from "../config/settings.js";
+import { HEADING, PROSE, sectionStartLine, sectionTitle } from "../document/model.js";
+import { codeSpans, plainText } from "../document/plainText.js";
+import { countIn, mean, pstdev, wordCount } from "../text.js";
+import { entriesFor, matchesIn } from "./dictionaries.js";
+import * as markers from "./markers.js";
+import { overlap, topicsOf, unionOf } from "./topics.js";
+
+/**
+ * @typedef {object} SentencePrint
+ * @property {number} index
+ * @property {number} line
+ * @property {string} text
+ * @property {number} blockIndex
+ * @property {number} paragraphIndex
+ * @property {number} sectionIndex
+ * @property {number} length 어절 수
+ * @property {string} ending
+ * @property {string} mood
+ * @property {number} commas
+ * @property {string | null} connectorStart
+ * @property {number} causal
+ * @property {string[]} deixis
+ * @property {number} euiCount
+ * @property {number} nounRun
+ * @property {string[]} passives
+ * @property {number} hedges
+ * @property {number} numbers
+ * @property {Set<string>} topics
+ * @property {string[]} promises
+ * @property {string[]} recalls
+ * @property {[number, string, string][]} countPromises
+ * @property {boolean} readerCall
+ * @property {import("./dictionaries.js").DictionaryMatch[]} matches
+ * @property {[number, number][]} quoted 인용 구간. 인라인 코드와 따옴표 쌍의 안
+ */
+
+/**
+ * @typedef {object} ParagraphPrint
+ * @property {number} index
+ * @property {number} blockIndex
+ * @property {number} sectionIndex
+ * @property {number} startLine
+ * @property {number} endLine
+ * @property {SentencePrint[]} sentences
+ * @property {number} sentenceCount
+ * @property {number} meanLength
+ * @property {number} lengthStd
+ * @property {number} causalTotal
+ * @property {number} deixisTotal
+ * @property {Set<string>} topics
+ * @property {number | null} overlapWithPrevious
+ * @property {boolean} followsProseDirectly
+ * @property {string} text
+ */
+
+/**
+ * @typedef {object} SectionPrint
+ * @property {number} index
+ * @property {string} title
+ * @property {number} level
+ * @property {number} startLine
+ * @property {ParagraphPrint[]} paragraphs
+ * @property {string[]} blockKinds
+ * @property {Set<string>} topics
+ * @property {boolean} isIntro
+ */
+
+/**
+ * @typedef {object} DocumentPrint
+ * @property {string | null} path
+ * @property {Record<string, string>} frontmatter
+ * @property {import("../document/model.js").Block[]} blocks
+ * @property {SentencePrint[]} sentences
+ * @property {ParagraphPrint[]} paragraphs
+ * @property {SectionPrint[]} sections
+ * @property {[number, string, number][]} headings (레벨, 제목, 줄)
+ * @property {number} wordCount
+ * @property {number} questionCount
+ * @property {number} readerCallCount
+ * @property {[number, string, number, string][]} countPromises (수, 단위, 줄, 원문)
+ * @property {[number, string][]} promises
+ * @property {[number, string][]} recalls
+ * @property {[string, number, number][]} disabled
+ * @property {SectionPrint} intro
+ * @property {SectionPrint[]} bodySections
+ */
+
+/**
+ * 문장 안의 인용 구간. 블록의 인라인 코드 구간을 문장 좌표로 옮기고 따옴표 쌍을 더한다.
+ * @param {import("../analysis/surface/splitSentences.js").Sentence} sentence
+ * @param {[number, number][]} blockCodeSpans
+ * @returns {[number, number][]}
+ */
+function quotedIn(sentence, blockCodeSpans) {
+  /** @type {[number, number][]} */
+  const spans = [];
+  for (const [start, end] of blockCodeSpans) {
+    const lo = Math.max(start, sentence.start);
+    const hi = Math.min(end, sentence.end);
+    if (lo < hi) spans.push([lo - sentence.start, hi - sentence.start]);
+  }
+  spans.push(...markers.quoteSpans(sentence.text));
+  const unique = new Map(spans.map((span) => [`${span[0]},${span[1]}`, span]));
+  return [...unique.values()].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+}
+
+/**
+ * @param {string} text
+ * @param {number} index
+ * @param {number} line
+ * @param {import("../document/model.js").Block} block
+ * @param {number} paragraphIndex
+ * @param {number} sectionIndex
+ * @param {import("../analysis/index.js").Analyzer} analyzer
+ * @param {import("./dictionaries.js").Entry[]} entries
+ * @param {[number, number][]} quoted
+ * @returns {SentencePrint}
+ */
+function makeSentencePrint(text, index, line, block, paragraphIndex, sectionIndex, analyzer, entries, quoted) {
+  const ending = markers.endingOf(text);
+  const deixis = markers
+    .matchedSpans(text, "deixis.txt")
+    .filter(([start, end]) => !markers.insideAny(start, end, quoted))
+    .map(([, , found]) => found);
+  const matches = matchesIn(text, entries).filter((m) => !markers.insideAny(m.start, m.end, quoted));
+  return {
+    index,
+    line,
+    text,
+    blockIndex: block.index,
+    paragraphIndex,
+    sectionIndex,
+    length: wordCount(text),
+    ending,
+    mood: markers.moodOf(text, ending),
+    commas: markers.countCommas(text),
+    connectorStart: markers.connectorStartOf(text),
+    causal: markers.countMatches(text, "causalMarkers.txt"),
+    deixis,
+    euiCount: analyzer.euiCount(text),
+    nounRun: analyzer.longestNounRun(text),
+    passives: analyzer.doublePassives(text),
+    hedges: markers.countMatches(text, "hedges.txt"),
+    numbers: markers.countNumbers(text),
+    topics: topicsOf(text),
+    promises: markers.matchedTexts(text, "promiseMarkers.txt"),
+    recalls: markers.matchedTexts(text, "recallMarkers.txt"),
+    countPromises: markers.countPromisesIn(text),
+    readerCall: markers.matchedTexts(text, "readerCalls.txt").length > 0,
+    matches,
+    quoted,
+  };
+}
+
+/**
+ * @param {SentencePrint[]} sentences
+ * @param {number} index
+ * @param {import("../document/model.js").Block} block
+ * @param {number} sectionIndex
+ * @param {ParagraphPrint | null} previous
+ * @param {boolean} followsProseDirectly
+ * @returns {ParagraphPrint}
+ */
+function makeParagraphPrint(sentences, index, block, sectionIndex, previous, followsProseDirectly) {
+  const lengths = sentences.map((s) => s.length);
+  const topics = unionOf(sentences.map((s) => s.topics));
+  return {
+    index,
+    blockIndex: block.index,
+    sectionIndex,
+    startLine: block.startLine,
+    endLine: block.endLine,
+    sentences,
+    sentenceCount: sentences.length,
+    meanLength: lengths.length ? mean(lengths) : 0,
+    lengthStd: lengths.length > 1 ? pstdev(lengths) : 0,
+    causalTotal: sentences.reduce((sum, s) => sum + s.causal, 0),
+    deixisTotal: sentences.reduce((sum, s) => sum + s.deixis.length, 0),
+    topics,
+    overlapWithPrevious: previous ? overlap(previous.topics, topics) : null,
+    followsProseDirectly,
+    text: sentences.map((s) => s.text).join(" "),
+  };
+}
+
+/**
+ * @param {import("../document/model.js").Section} section
+ * @param {number} sectionIndex
+ * @param {import("../analysis/index.js").Analyzer} analyzer
+ * @param {import("./dictionaries.js").Entry[]} entries
+ * @param {SentencePrint[]} sentences
+ * @param {ParagraphPrint[]} paragraphs
+ * @returns {SectionPrint}
+ */
+function buildSection(section, sectionIndex, analyzer, entries, sentences, paragraphs) {
+  /** @type {ParagraphPrint[]} */
+  const sectionParagraphs = [];
+  /** @type {import("../document/model.js").Block | null} */
+  let previousBlock = null;
+  for (const block of section.blocks) {
+    if (block.kind !== PROSE) {
+      previousBlock = block;
+      continue;
+    }
+    const text = plainText(block.text);
+    const blockCodeSpans = codeSpans(block.text, text);
+    /** @type {SentencePrint[]} */
+    const blockSentences = [];
+    for (const sentence of analyzer.sentences(text)) {
+      const line = block.startLine + countIn(text, "\n", sentence.start);
+      const index = sentences.length + blockSentences.length;
+      const quoted = quotedIn(sentence, blockCodeSpans);
+      blockSentences.push(
+        makeSentencePrint(sentence.text, index, line, block, paragraphs.length, sectionIndex, analyzer, entries, quoted),
+      );
+    }
+    sentences.push(...blockSentences);
+    const previous = sectionParagraphs.length ? sectionParagraphs[sectionParagraphs.length - 1] : null;
+    const paragraph = makeParagraphPrint(
+      blockSentences,
+      paragraphs.length,
+      block,
+      sectionIndex,
+      previous,
+      previousBlock !== null && previousBlock.kind === PROSE,
+    );
+    paragraphs.push(paragraph);
+    sectionParagraphs.push(paragraph);
+    previousBlock = block;
+  }
+  const level = section.heading ? section.heading.level : 0;
+  return {
+    index: sectionIndex,
+    title: sectionTitle(section),
+    level,
+    startLine: sectionStartLine(section),
+    paragraphs: sectionParagraphs,
+    blockKinds: section.blocks.map((b) => b.kind),
+    topics: unionOf(sectionParagraphs.map((p) => p.topics)),
+    isIntro: level === 0,
+  };
+}
+
+/**
+ * @param {import("../document/model.js").Document} doc
+ * @param {import("../analysis/index.js").Analyzer} analyzer
+ * @param {import("../config/settings.js").Config} [config]
+ * @returns {DocumentPrint}
+ */
+export function buildFingerprint(doc, analyzer, config = defaultConfig()) {
+  const entries = entriesFor(config);
+  /** @type {SentencePrint[]} */
+  const sentences = [];
+  /** @type {ParagraphPrint[]} */
+  const paragraphs = [];
+  const sections = doc.sections.map((section, index) =>
+    buildSection(section, index, analyzer, entries, sentences, paragraphs),
+  );
+  const headingBlocks = doc.blocks.filter((b) => b.kind === HEADING);
+  /** @type {[number, string, number][]} */
+  const headings = headingBlocks.map((b) => [b.level, b.text, b.startLine]);
+  const headingQuestions = headingBlocks.filter((b) => b.text.includes("?")).length;
+  return {
+    path: doc.path,
+    frontmatter: { ...doc.frontmatter },
+    blocks: doc.blocks,
+    sentences,
+    paragraphs,
+    sections,
+    headings,
+    wordCount: sentences.reduce((sum, s) => sum + s.length, 0),
+    questionCount: sentences.filter((s) => s.mood === "의문").length + headingQuestions,
+    readerCallCount: sentences.filter((s) => s.readerCall || s.mood === "명령").length,
+    countPromises: sentences.flatMap((s) => s.countPromises.map(([n, unit, text]) => [n, unit, s.line, text])),
+    promises: sentences.flatMap((s) => s.promises.map((text) => [s.line, text])),
+    recalls: sentences.flatMap((s) => s.recalls.map((text) => [s.line, text])),
+    disabled: doc.disabled,
+    intro: sections[0],
+    bodySections: sections.filter((s) => !s.isIntro),
+  };
+}

package/src/fingerprint/dictionaries.js

@@ -0,0 +1,118 @@
+// @ts-check
+/** 사전 넷을 한 번 컴파일하고 문장에서 맞는 자리를 찾는다. 설정의 dictionary 항목을 더한다. */
+import { loadEntries } from "../data/load.js";
+import { compile } from "../regex.js";
+
+export const DICTIONARY_FILES = {
+  cliches: "cliches.toml",
+  translationese: "translationese.toml",
+  redundantPair: "redundantPair.toml",
+  japaneseLoan: "japaneseLoan.toml",
+  spelling: "spelling.toml",
+  spacing: "spacing.toml",
+  confusable: "confusable.toml",
+  easyWords: "easyWords.toml",
+};
+const GROUP_REF = /\$(\d)/g;
+const FINALS = { ㄴ: 4, ㄹ: 8 };
+// {조사} 자리표시자. 낱말 뒤에 조사가 붙었거나 낱말이 끝나는 자리. 파이썬 dictionaries.py 와 같은 글자다.
+const JOSA_TAIL = "(?=(?:에서는|으로는|에서|에게|까지|부터|보다|처럼|으로|이나|은|는|이|가|을|를|의|에|로|와|과|도|만)?(?![가-힣]))";
+const PLACEHOLDER = /\{(ㄴ|ㄹ|조사)\}/g;
+
+/** 받침으로 끝나는 음절 399개의 문자 부류. @param {"ㄴ" | "ㄹ"} final */
+function syllableClass(final) {
+  let chars = "";
+  for (let initial = 0; initial < 19; initial++) {
+    for (let vowel = 0; vowel < 21; vowel++) chars += String.fromCharCode(0xac00 + (initial * 21 + vowel) * 28 + FINALS[final]);
+  }
+  return `[${chars}]`;
+}
+
+/** @param {string} pattern */
+export function expandClasses(pattern) {
+  return pattern.replace(PLACEHOLDER, (_, name) => (name === "조사" ? JOSA_TAIL : syllableClass(name)));
+}
+
+/**
+ * @typedef {object} Entry
+ * @property {string} dictionary
+ * @property {import("../regex.js").Pattern} pattern
+ * @property {string} why
+ * @property {string} source
+ * @property {string | null} fix
+ */
+
+/**
+ * @typedef {object} DictionaryMatch
+ * @property {string} dictionary
+ * @property {string} text
+ * @property {number} start
+ * @property {number} end
+ * @property {string} why
+ * @property {string} source
+ * @property {string | null} fix
+ */
+
+/** @param {string} dictionary @param {Record<string, unknown> | string} raw @returns {Entry} */
+export function entryFrom(dictionary, raw) {
+  const data = typeof raw === "string" ? { pattern: raw } : raw;
+  return {
+    dictionary,
+    pattern: compile(expandClasses(/** @type {string} */ (data.pattern))),
+    why: /** @type {string} */ (data.why ?? "설정에서 더한 항목"),
+    source: /** @type {string} */ (data.source ?? "설정"),
+    fix: /** @type {string | null} */ (data.fix ?? null),
+  };
+}
+
+/** @type {Entry[] | null} */
+let builtinCache = null;
+export function builtinEntries() {
+  if (!builtinCache) {
+    builtinCache = [];
+    for (const [dictionary, name] of Object.entries(DICTIONARY_FILES)) {
+      for (const raw of loadEntries(name)) builtinCache.push(entryFrom(dictionary, raw));
+    }
+  }
+  return builtinCache;
+}
+
+/** @param {import("../config/settings.js").Config} config @returns {Entry[]} */
+export function entriesFor(config) {
+  /** @type {Entry[]} */
+  const extra = [];
+  for (const [dictionary, items] of Object.entries(config.dictionary)) {
+    if (!(dictionary in DICTIONARY_FILES)) {
+      throw new Error(`모르는 사전: ${dictionary}. ${Object.keys(DICTIONARY_FILES).join(", ")} 가운데 하나다`);
+    }
+    for (const raw of items) extra.push(entryFrom(dictionary, /** @type {Record<string, unknown> | string} */ (raw)));
+  }
+  return [...builtinEntries(), ...extra];
+}
+
+/** @param {RegExpExecArray} match @param {string} fix */
+export function applyFix(match, fix) {
+  return fix.replace(GROUP_REF, (_, n) => match[Number(n)] ?? "");
+}
+
+/** @param {string} text @param {Entry[]} entries @returns {DictionaryMatch[]} */
+export function matchesIn(text, entries) {
+  /** @type {DictionaryMatch[]} */
+  const found = [];
+  for (const entry of entries) {
+    for (const match of entry.pattern.all(text)) {
+      const start = /** @type {number} */ (match.index);
+      found.push({
+        dictionary: entry.dictionary,
+        text: match[0],
+        start,
+        end: start + match[0].length,
+        why: entry.why,
+        source: entry.source,
+        fix: entry.fix ? applyFix(match, entry.fix) : null,
+      });
+    }
+  }
+  found.sort((a, b) => a.start - b.start);
+  return found;
+}

package/src/fingerprint/markers.js

@@ -0,0 +1,175 @@
+// @ts-check
+/**
+ * 문장에서 표지를 센다. 종결어미 부류, 서법, 접속부사, 인과, 지시어, 헤지, 약속과 회수, 독자 호출, 수 약속.
+ * 낱말 목록은 전부 data/ 가 정본이다. 파이썬 fingerprint/markers.py 와 같다.
+ */
+import { loadLines, loadPatterns } from "../data/load.js";
+import { compile, escape } from "../regex.js";
+
+const TRAILING = /[\s.?!"'”’)\]]+$/;
+const NUMBER = /\d+(?:[.,]\d+)*/g;
+const COMMA = /,/g;
+// 따옴표 쌍. 안은 사용이 아니라 인용이다. 작은따옴표는 앞이 문장 첫머리나 공백이나 여는 괄호일 때만.
+const QUOTE_PAIRS = [
+  /"([^"\n]{1,80})"/g,
+  /“([^“”\n]{1,80})”/g,
+  /‘([^‘’\n]{1,80})’/g,
+  /「([^「」\n]{1,80})」/g,
+  /『([^『』\n]{1,80})』/g,
+  /(?<=^|[\s(])'([^'\n]{1,80})'/g,
+];
+const CONNECTOR_LOOKAHEAD = /(?=[\s,])/.source;
+const NO_HANGUL_BEFORE = /(?<![가-힣])/.source;
+const DIGITS = /\d+/.source;
+const OPTIONAL_SPACE = /\s?/.source;
+
+/** @type {Record<string, number> | null} */
+let numberCache = null;
+/** 수사 → 값. 정본은 data/koreanNumbers.txt. */
+export function koreanNumbers() {
+  if (!numberCache) {
+    numberCache = {};
+    for (const line of loadLines("koreanNumbers.txt")) {
+      const [word, value] = line.split("\t");
+      numberCache[word] = parseInt(value, 10);
+    }
+  }
+  return numberCache;
+}
+
+/** @type {[string, import("../regex.js").Pattern][] | null} */
+let endingCache = null;
+export function endingClasses() {
+  if (!endingCache) {
+    endingCache = loadLines("endings.txt").map((line) => {
+      const at = line.indexOf("\t");
+      return [line.slice(0, at), compile(line.slice(at + 1))];
+    });
+  }
+  return endingCache;
+}
+
+/** @type {import("../regex.js").Pattern | null} */
+let connectorCache = null;
+export function connectorPattern() {
+  if (!connectorCache) {
+    const names = [...loadLines("connectors.txt")].sort((a, b) => b.length - a.length);
+    connectorCache = compile(`^(${names.map(escape).join("|")})${CONNECTOR_LOOKAHEAD}`);
+  }
+  return connectorCache;
+}
+
+/** @type {import("../regex.js").Pattern | null} */
+let countCache = null;
+export function countPromisePattern() {
+  if (!countCache) {
+    const units = loadLines("countUnits.txt").map(escape).join("|");
+    const numbers = Object.keys(koreanNumbers())
+      .sort((a, b) => b.length - a.length)
+      .join("|");
+    // 단위 뒤에는 조사가 붙는 것이 정상이다 (여섯 가지를). 앞쪽만 경계를 본다.
+    countCache = compile(`${NO_HANGUL_BEFORE}(${numbers}|${DIGITS})${OPTIONAL_SPACE}(${units})`);
+  }
+  return countCache;
+}
+
+/** @param {string} text */
+export function stripTrailing(text) {
+  return text.trim().replace(TRAILING, "");
+}
+
+/** @param {string} text */
+export function endingOf(text) {
+  const body = stripTrailing(text);
+  for (const [kind, pattern] of endingClasses()) {
+    if (pattern.search(body)) return kind;
+  }
+  return "없음";
+}
+
+/** @param {string} text @param {string} ending */
+export function moodOf(text, ending) {
+  const stripped = text.trim();
+  if (stripped.endsWith("?") || ending === "의문") return "의문";
+  if (ending === "명령") return "명령";
+  return "평서";
+}
+
+/** @param {string} text */
+export function connectorStartOf(text) {
+  const match = connectorPattern().at(text.trim());
+  return match ? match[1] : null;
+}
+
+/** @param {string} text @param {string} patternFile */
+export function countMatches(text, patternFile) {
+  let total = 0;
+  for (const pattern of loadPatterns(patternFile)) total += pattern.all(text).length;
+  return total;
+}
+
+/** @param {string} text @param {string} patternFile @returns {string[]} */
+export function matchedTexts(text, patternFile) {
+  /** @type {string[]} */
+  const found = [];
+  for (const pattern of loadPatterns(patternFile)) {
+    for (const match of pattern.all(text)) found.push(match[0]);
+  }
+  return found;
+}
+
+/** (시작, 끝, 원문). 인용 구간 안의 것을 거를 때 쓴다. @param {string} text @param {string} patternFile @returns {[number, number, string][]} */
+export function matchedSpans(text, patternFile) {
+  /** @type {[number, number, string][]} */
+  const found = [];
+  for (const pattern of loadPatterns(patternFile)) {
+    for (const match of pattern.all(text)) {
+      const start = /** @type {number} */ (match.index);
+      found.push([start, start + match[0].length, match[0]]);
+    }
+  }
+  return found;
+}
+
+/** 따옴표 쌍 안의 [시작, 끝]. 인용은 사용이 아니다. @param {string} text @returns {[number, number][]} */
+export function quoteSpans(text) {
+  /** @type {[number, number][]} */
+  const found = [];
+  for (const pattern of QUOTE_PAIRS) {
+    pattern.lastIndex = 0;
+    for (const match of text.matchAll(pattern)) {
+      const start = /** @type {number} */ (match.index) + match[0].indexOf(match[1]);
+      found.push([start, start + match[1].length]);
+    }
+  }
+  return found.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+}
+
+/** @param {number} start @param {number} end @param {[number, number][]} spans */
+export function insideAny(start, end, spans) {
+  return spans.some(([spanStart, spanEnd]) => spanStart <= start && end <= spanEnd);
+}
+
+/** @param {string} text @returns {[number, string, string][]} (수, 단위, 원문) */
+export function countPromisesIn(text) {
+  /** @type {[number, string, string][]} */
+  const found = [];
+  for (const match of countPromisePattern().all(text)) {
+    const raw = match[1];
+    const unit = match[2];
+    if (/^\d+$/.test(raw) && unit === "단계" && !match[0].includes(" ")) continue;
+    const number = koreanNumbers()[raw] ?? parseInt(raw, 10);
+    found.push([number, unit, match[0]]);
+  }
+  return found;
+}
+
+/** @param {string} text */
+export function countNumbers(text) {
+  return [...text.matchAll(NUMBER)].length;
+}
+
+/** @param {string} text */
+export function countCommas(text) {
+  return [...text.matchAll(COMMA)].length;
+}

package/src/fingerprint/topics.js

@@ -0,0 +1,42 @@
+// @ts-check
+/** 화제어 집합. 조사를 뗀 명사 어절의 근사. 파이썬 fingerprint/topics.py 와 같다. */
+import { stripJosa, tailOf, words } from "../analysis/surface/tokenize.js";
+import { loadLines } from "../data/load.js";
+
+const WORD = /^[가-힣A-Za-z][가-힣A-Za-z0-9]*$/;
+
+/** @type {Set<string> | null} */
+let stopwordCache = null;
+function stopwords() {
+  if (!stopwordCache) stopwordCache = new Set(loadLines("stopwords.txt"));
+  return stopwordCache;
+}
+
+/** @param {string} text @returns {Set<string>} */
+export function topicsOf(text) {
+  const found = new Set();
+  for (const word of words(text)) {
+    const core = stripJosa(word.core);
+    if (!WORD.test(core) || stopwords().has(core)) continue;
+    // 한 글자는 조사가 붙어 있던 것만 명사로 본다 (표를, 값이, 열은). 홀로 선 한 글자는 잡음이다.
+    if (core.length < 2 && core === word.core) continue;
+    if (tailOf(core, "verbTails.txt")) continue;
+    found.add(core.toLowerCase());
+  }
+  return found;
+}
+
+/** 자카드 유사도. 둘 다 비어 있으면 0. @param {Set<string>} a @param {Set<string>} b */
+export function overlap(a, b) {
+  if (!a.size || !b.size) return 0;
+  let shared = 0;
+  for (const item of a) if (b.has(item)) shared += 1;
+  return shared / (a.size + b.size - shared);
+}
+
+/** @param {Iterable<Set<string>>} sets */
+export function unionOf(sets) {
+  const result = new Set();
+  for (const set of sets) for (const item of set) result.add(item);
+  return result;
+}

package/src/index.js

@@ -0,0 +1,68 @@
+// @ts-check
+/**
+ * hanlint: 한국어 글에서 AI 와 사람이 반복해서 어기는 결함을 결정적으로 잡는 린터. 공개 표면은 이 파일 한 곳이다.
+ *
+ * ```js
+ * import { lintText, lintFile } from "hanlint";
+ * for (const f of lintFile("글.md")) console.log(f.line, f.rule, f.why);
+ * ```
+ *
+ * 합격과 불합격을 판정하지 않는다. 지적 목록이 비어 있다는 것은 세어서 잡히는 결함이 없다는 뜻이다.
+ * 지문 지도 (audit, map), 프로파일, kiwi 정밀 모드는 파이썬 패키지에 있다.
+ */
+import { readFileSync } from "node:fs";
+
+import { makeAnalyzer } from "./analysis/index.js";
+import { loadConfig } from "./config/loadConfig.js";
+import { configFromMapping, defaultConfig } from "./config/settings.js";
+import { loadVersion } from "./data/load.js";
+import { parseMarkdown } from "./document/parseMarkdown.js";
+import { applyFixes } from "./edit/applyFixes.js";
+import { buildFingerprint } from "./fingerprint/build.js";
+import { fingerprintDict } from "./report/fingerprintJson.js";
+import { ruleDoc, ruleNames, ruleSummary, runAll } from "./rules/registry.js";
+
+export { applyFixes, configFromMapping, defaultConfig, fingerprintDict, loadConfig, ruleDoc, ruleNames, ruleSummary };
+export const version = loadVersion();
+
+/** @type {Map<string, import("./analysis/index.js").Analyzer>} */
+const analyzers = new Map();
+
+/** @param {import("./config/settings.js").Config} config */
+export function analyzerFor(config) {
+  let analyzer = analyzers.get(config.analyzer);
+  if (!analyzer) {
+    analyzer = makeAnalyzer(config.analyzer);
+    analyzers.set(config.analyzer, analyzer);
+  }
+  return analyzer;
+}
+
+/**
+ * 글을 한 번 읽어 지문을 만든다.
+ * @param {string} text
+ * @param {import("./config/settings.js").Config} [config]
+ * @param {string | null} [path]
+ */
+export function fingerprint(text, config = defaultConfig(), path = null) {
+  return buildFingerprint(parseMarkdown(text, path), analyzerFor(config), config);
+}
+
+/**
+ * 문자열을 검사해 줄 번호 순의 지적 목록을 준다.
+ * @param {string} text
+ * @param {import("./config/settings.js").Config} [config]
+ * @param {string | null} [path]
+ */
+export function lintText(text, config = defaultConfig(), path = null) {
+  return runAll(fingerprint(text, config, path), config);
+}
+
+/**
+ * 파일을 UTF-8 로 읽어 검사한다.
+ * @param {string} path
+ * @param {import("./config/settings.js").Config} [config]
+ */
+export function lintFile(path, config = defaultConfig()) {
+  return lintText(readFileSync(path, "utf-8"), config, path);
+}