hanlint 0.0.7 → 0.0.9

package/src/analysis/grammar/hangul.js

@@ -0,0 +1,94 @@
+// @ts-check
+/**
+ * 한글 음절의 자모 산술. 파이썬 `analysis/grammar/hangul.py` 의 투영이다. 표 대신 산술로 하는 까닭은 그 파일이 소유한다.
+ */
+
+export const BASE = 0xac00;
+export const LAST = 0xd7a3;
+export const VOWELS = 21;
+export const FINALS = 28;
+
+// 중성 자리 번호. ㅏ ㅐ ㅑ ㅒ ㅓ ㅔ ㅕ ㅖ ㅗ ㅘ ㅙ ㅚ ㅛ ㅜ ㅝ ㅞ ㅟ ㅠ ㅡ ㅢ ㅣ 차례다.
+export const A = 0;
+export const AE = 1;
+export const YA = 2;
+export const YAE = 3;
+export const EO = 4;
+export const E = 5;
+export const YEO = 6;
+export const YE = 7;
+export const OH = 8;
+export const WA = 9;
+export const WAE = 10;
+export const OE = 11;
+export const YO = 12;
+export const U = 13;
+export const WO = 14;
+export const WE = 15;
+export const WI = 16;
+export const YU = 17;
+export const EU = 18;
+export const UI = 19;
+export const IH = 20;
+
+// 종성 자리 번호 가운데 형태 층이 이름으로 부르는 것.
+export const NONE = 0;
+export const GIYEOK = 1;
+export const NIEUN = 4;
+export const DIGEUT = 7;
+export const RIEUL = 8;
+export const MIEUM = 16;
+export const BIEUP = 17;
+export const SIOT = 19;
+export const SSANGSIOT = 20;
+export const IEUNG = 21;
+export const HIEUT = 27;
+
+/** 양성 모음. 이 모음 뒤에는 `아` 가 붙고 나머지에는 `어` 가 붙는다. */
+export const BRIGHT = new Set([A, OH, YA, YO, WA]);
+
+/** @param {string} ch */
+export function isSyllable(ch) {
+  if (ch.length !== 1) return false;
+  const code = ch.charCodeAt(0);
+  return code >= BASE && code <= LAST;
+}
+
+/** (초성, 중성, 종성) 자리 번호. @param {string} ch @returns {[number, number, number]} */
+export function split(ch) {
+  if (!isSyllable(ch)) throw new Error(`한글 음절이 아니다: ${JSON.stringify(ch)}`);
+  const code = ch.charCodeAt(0) - BASE;
+  return [Math.floor(code / (VOWELS * FINALS)), Math.floor(code / FINALS) % VOWELS, code % FINALS];
+}
+
+/** @param {number} initial @param {number} vowel @param {number} [final] */
+export function join(initial, vowel, final = NONE) {
+  return String.fromCharCode(BASE + (initial * VOWELS + vowel) * FINALS + final);
+}
+
+/** 음절의 종성 번호. 한글 음절이 아니면 null. @param {string} ch */
+export function finalOf(ch) {
+  return isSyllable(ch) ? split(ch)[2] : null;
+}
+
+/** @param {string} ch */
+export function vowelOf(ch) {
+  return isSyllable(ch) ? split(ch)[1] : null;
+}
+
+/** @param {string} ch @param {number} final */
+export function withFinal(ch, final) {
+  const [initial, vowel] = split(ch);
+  return join(initial, vowel, final);
+}
+
+/** @param {string} ch @param {number} vowel */
+export function withVowel(ch, vowel) {
+  const [initial, , final] = split(ch);
+  return join(initial, vowel, final);
+}
+
+/** 낱말의 마지막 한글 음절. 없으면 null. @param {string} word */
+export function lastSyllable(word) {
+  return word && isSyllable(word[word.length - 1]) ? word[word.length - 1] : null;
+}

package/src/analysis/grammar/index.js

@@ -0,0 +1,5 @@
+export * from "./ending.js";
+export * from "./hangul.js";
+export * from "./josa.js";
+export * from "./register.js";
+export * from "./voice.js";

package/src/analysis/grammar/josa.js

@@ -0,0 +1,73 @@
+// @ts-check
+/** 파이썬 `analysis/grammar/josa.py`의 투영. 받침에 따라 조사 꼴을 맞춘다. */
+import * as hangul from "./hangul.js";
+
+const PAIRS = [
+  ["으로부터", "로부터"],
+  ["으로서", "로서"],
+  ["으로써", "로써"],
+  ["이라고", "라고"],
+  ["이라서", "라서"],
+  ["이라는", "라는"],
+  ["이라면", "라면"],
+  ["이나마", "나마"],
+  ["으로", "로"],
+  ["이란", "란"],
+  ["이라", "라"],
+  ["이며", "며"],
+  ["이랑", "랑"],
+  ["이든", "든"],
+  ["이나", "나"],
+  ["이여", "여"],
+  ["이야", "야"],
+  ["은", "는"],
+  ["이", "가"],
+  ["을", "를"],
+  ["과", "와"],
+  ["아", "야"],
+];
+const DIGIT_FINALS = [hangul.IEUNG, hangul.RIEUL, hangul.NONE, hangul.MIEUM, hangul.NONE, hangul.NONE, hangul.GIYEOK, hangul.RIEUL, hangul.RIEUL, hangul.NONE];
+const PLACE_FINALS = { 1: hangul.BIEUP, 2: hangul.GIYEOK, 3: hangul.NIEUN };
+const GROUP_FINALS = [hangul.NIEUN, hangul.GIYEOK, hangul.NONE, hangul.IEUNG];
+const ALNUM = /[\p{L}\p{N}]/u;
+
+/** @param {string} digits */
+export function digitFinal(digits) {
+  const body = digits.replace(/0+$/, "");
+  if (!body) return DIGIT_FINALS[0];
+  const zeros = digits.length - body.length;
+  if (zeros === 0) return DIGIT_FINALS[Number(digits.at(-1))];
+  if (zeros >= 4) return GROUP_FINALS[Math.min(Math.floor(zeros / 4), GROUP_FINALS.length) - 1];
+  return PLACE_FINALS[zeros];
+}
+
+/** @param {string} word */
+export function finalOf(word) {
+  if (!word) return null;
+  if (/[0-9]$/.test(word)) return digitFinal(/[0-9]+$/.exec(word)[0]);
+  return hangul.finalOf(word.at(-1));
+}
+
+/** @param {string} word @param {string} following */
+export function josaSwap(word, following) {
+  const final = finalOf(word);
+  if (final === null || !following) return null;
+  for (const [withFinal, withoutFinal] of PAIRS) {
+    for (const form of [withFinal, withoutFinal]) {
+      if (!following.startsWith(form)) continue;
+      const rest = following.slice(form.length);
+      if (rest && ALNUM.test(rest[0])) break;
+      const wanted = withFinal === "으로"
+        ? (final === hangul.NONE || final === hangul.RIEUL ? withoutFinal : withFinal)
+        : (final ? withFinal : withoutFinal);
+      return wanted === form ? null : [form, wanted];
+    }
+  }
+  return null;
+}
+
+/** @param {string} word @param {string} following */
+export function fitJosa(word, following) {
+  const swap = josaSwap(word, following);
+  return swap ? swap[1] + following.slice(swap[0].length) : following;
+}

package/src/analysis/grammar/register.js

@@ -0,0 +1,115 @@
+// @ts-check
+/** 파이썬 `analysis/grammar/register.py`의 투영. 글의 문체를 판별하고 문장 끝 서술어를 맞춘다. */
+import * as hangul from "./hangul.js";
+import { HAEYO, HANDA, HAPNIDA, REGISTERS, parsePredicate, render } from "./ending.js";
+
+export const MIXED = "섞임";
+export const NONE = "없음";
+const SENTENCE_END = /([가-힣]+)([.?!]+)(["”’\)\]]*)(?=\s|$)/g;
+const WORD_BEFORE = /(\S+)\s+$/;
+const SKIP_LINE = /^\s*(#|\||```|---)/;
+const TEMPLATE_WORD = /\{([가-힣]+)\}/g;
+const BARE_LINE_END = /([가-힣]+)$/gm;
+
+/** @param {string} word */
+export function registerOfWord(word) {
+  if (word.endsWith("습니다") || (word.endsWith("니다") && word.length >= 3 && hangul.finalOf(word.at(-3)) === hangul.BIEUP)) {
+    return HAPNIDA;
+  }
+  if (word.endsWith("요")) return HAEYO;
+  if (word.endsWith("다")) return HANDA;
+  return null;
+}
+
+/** @param {string} text */
+export function lastWord(text) {
+  const body = text.trimEnd().replace(/[.?!"”’\)\]」』]+$/, "");
+  return /([가-힣]+)$/.exec(body)?.[1] ?? "";
+}
+
+/** @param {string[]} words @param {number} minShare @returns {[string, number]} */
+export function documentRegister(words, minShare) {
+  const counted = new Map();
+  for (const word of words) {
+    const found = registerOfWord(word);
+    if (found) counted.set(found, (counted.get(found) ?? 0) + 1);
+  }
+  const total = [...counted.values()].reduce((sum, count) => sum + count, 0);
+  if (!total) return [NONE, 0];
+  const [register, count] = [...counted.entries()].sort((a, b) => b[1] - a[1] || REGISTERS.indexOf(b[0]) - REGISTERS.indexOf(a[0]))[0];
+  const share = count / total;
+  return [share >= minShare ? register : MIXED, share];
+}
+
+/** @param {string} line @param {string} target @returns {[string, number, number]} */
+export function convertLine(line, target) {
+  let converted = 0;
+  let skipped = 0;
+  const text = line.replace(SENTENCE_END, (whole, word, punct, close, offset) => {
+    if (registerOfWord(word) === null) return whole;
+    const before = WORD_BEFORE.exec(line.slice(0, offset));
+    const value = parsePredicate(word, before ? before[1] : null);
+    if (!value) {
+      skipped += 1;
+      return whole;
+    }
+    converted += 1;
+    return render(value, target) + punct + close;
+  });
+  return [text, converted, skipped];
+}
+
+/** @param {string} text @param {string} target @returns {{text: string, converted: number, skipped: number}} */
+export function convertRegister(text, target) {
+  if (!REGISTERS.includes(target)) throw new Error(`모르는 문체: ${target}. ${REGISTERS.join(", ")} 가운데 하나다`);
+  const out = [];
+  let converted = 0;
+  let skipped = 0;
+  let inFence = false;
+  for (const line of text.split("\n")) {
+    if (line.trimStart().startsWith("```")) {
+      inFence = !inFence;
+      out.push(line);
+      continue;
+    }
+    if (inFence || SKIP_LINE.test(line)) {
+      out.push(line);
+      continue;
+    }
+    const [changed, found, missed] = convertLine(line, target);
+    out.push(changed);
+    converted += found;
+    skipped += missed;
+  }
+  return { text: out.join("\n"), converted, skipped };
+}
+
+/** 문형의 중괄호 속 활용 자리까지 문체를 바꾼다. @param {string} text @param {string} target */
+export function convertTemplate(text, target) {
+  const result = convertRegister(text, target);
+  let converted = result.converted;
+  let skipped = result.skipped;
+  const bare = result.text.replace(BARE_LINE_END, (whole, word, offset) => {
+    if (registerOfWord(word) === null) return whole;
+    const lineStart = result.text.lastIndexOf("\n", offset) + 1;
+    const before = WORD_BEFORE.exec(result.text.slice(lineStart, offset));
+    const value = parsePredicate(word, before ? before[1] : null);
+    if (!value) {
+      skipped += 1;
+      return whole;
+    }
+    converted += 1;
+    return render(value, target);
+  });
+  const changed = bare.replace(TEMPLATE_WORD, (whole, word) => {
+    if (registerOfWord(word) === null) return whole;
+    const value = parsePredicate(word);
+    if (!value) {
+      skipped += 1;
+      return whole;
+    }
+    converted += 1;
+    return `{${render(value, target)}}`;
+  });
+  return { text: changed, converted, skipped };
+}

package/src/analysis/grammar/voice.js

@@ -0,0 +1,43 @@
+// @ts-check
+/** 파이썬 `analysis/grammar/voice.py`의 투영. 확정되는 사동과 피동의 겹만 분해한다. */
+import { loadLines } from "../../data/load.js";
+
+export const PASSIVE = "피동";
+export const CAUSATIVE = "사동";
+const CAUSATIVE_FORM = /^([가-힣]+)게\s+만들([가-힣]*)$/;
+const CONTRACTION = new Map([
+  ["이", "여"],
+  ["히", "혀"],
+  ["리", "려"],
+  ["기", "겨"],
+]);
+let passiveCache = null;
+
+function passiveLinks() {
+  if (!passiveCache) {
+    passiveCache = new Map([["되어지", "되"]]);
+    for (const stem of loadLines("passiveStems.txt")) {
+      const last = stem.at(-1);
+      const linked = CONTRACTION.has(last) ? stem.slice(0, -1) + CONTRACTION.get(last) : stem + "어";
+      passiveCache.set(linked + "지", stem);
+    }
+  }
+  return passiveCache;
+}
+
+/** @param {string} surface */
+export function decomposePassive(surface) {
+  const base = passiveLinks().get(surface);
+  return base === undefined ? null : { surface, kind: PASSIVE, base, markers: ["접미 피동", "어지"], reduced: base };
+}
+
+/** @param {string} surface */
+export function decomposeCausative(surface) {
+  const match = CAUSATIVE_FORM.exec(surface);
+  return match ? { surface, kind: CAUSATIVE, base: match[1], markers: ["게", "만들"], reduced: null } : null;
+}
+
+/** @param {string} surface */
+export function decomposeVoice(surface) {
+  return decomposePassive(surface) ?? decomposeCausative(surface);
+}

package/src/analysis/index.js

@@ -1,34 +1,7 @@
 // @ts-check
 /**
- * 분석기. 지문 생성이 필요로 하는 넷만 드러낸다. sentences, euiCount, longestNounRun, doublePassives.
- * npm 에는 의존성 0 의 surface 만 있다. kiwi 정밀 모드는 파이썬 패키지 (`pip install hanlint[kiwi]`) 에 있다.
+ * 분석 층. 문장 분리와 어절 판정을 표층 (어절과 꼬리 사전) 으로 한다. 형태소 분석기는 없다. 파이썬 analysis/__init__.py 와 같다.
+ * 지문이 필요로 하는 것은 넷이다. splitSentences, euiCount 와 euiAdjacent, longestNounRun, doublePassives.
  */
-import { splitSentences } from "./surface/splitSentences.js";
-import * as tokenize from "./surface/tokenize.js";
-
-/**
- * @typedef {object} Analyzer
- * @property {string} name
- * @property {(text: string) => import("./surface/splitSentences.js").Sentence[]} sentences
- * @property {(sentence: string) => number} euiCount
- * @property {(sentence: string) => number} longestNounRun
- * @property {(sentence: string) => string[]} doublePassives
- */
-
-/** @type {Analyzer} */
-export const surfaceAnalyzer = {
-  name: "surface",
-  sentences: splitSentences,
-  euiCount: tokenize.euiCount,
-  longestNounRun: tokenize.longestNounRun,
-  doublePassives: tokenize.doublePassives,
-};
-
-/** @param {string} name @returns {Analyzer} */
-export function makeAnalyzer(name) {
-  if (name === "surface") return surfaceAnalyzer;
-  if (name === "kiwi") {
-    throw new Error("kiwi 분석기는 파이썬 패키지에 있다 (pip install hanlint[kiwi]). npm 에서는 --analyzer surface 를 쓴다");
-  }
-  throw new Error(`모르는 분석기: ${name}. surface 를 쓴다`);
-}
+export { splitSentences } from "./splitSentences.js";
+export { doublePassives, doublePassiveSpans, euiAdjacent, euiCount, longestNounRun } from "./tokenize.js";

package/src/analysis/josa.js

@@ -0,0 +1,2 @@
+// 이전 deep path 호환. 정본 투영은 grammar/josa.js다.
+export * from "./grammar/josa.js";

package/src/analysis/{surface/splitSentences.js → splitSentences.js}

@@ -1,5 +1,5 @@
 // @ts-check
-/** 종결 부호 뒤 공백에서 문장을 나눈다. 파이썬 analysis/surface/splitSentences.py 와 같다. */
+/** 종결 부호 뒤 공백에서 문장을 나눈다. 파이썬 analysis/splitSentences.py 와 같다. */
 
 const TERMINAL = /[.?!]+\s+(?=\S)/g;
 const ABBREVIATION = /(?:^|[^A-Za-z])[A-Za-z]$/;

package/src/analysis/{surface/tokenize.js → tokenize.js}

@@ -1,17 +1,21 @@
 // @ts-check
 /**
- * 어절 단위 근사. 조사와 어미 꼬리 사전으로 명사 어절을 가려낸다. 파이썬 analysis/surface/tokenize.py 와 같은 판정이다.
+ * 어절 단위 근사. 조사와 어미 꼬리 사전으로 명사 어절을 가려낸다. 파이썬 analysis/tokenize.py 와 같은 판정이다.
  * 띄어 쓴 조사와 계사는 앞 어절에 붙은 것으로, 영문 어절 연속은 한 덩어리로, 수사와 바로 뒤 단위는 수량으로 본다.
  */
-import { loadLines } from "../../data/load.js";
-import { splitWords, stripChars } from "../../text.js";
+import { loadLines } from "../data/load.js";
+import { splitWords, stripChars } from "../text.js";
 
 const HANGUL = /[가-힣]/;
+const HANGUL_WORD = /^[가-힣]+$/;
 const WORD_CHARS = /^[가-힣A-Za-z0-9]+$/;
-const GENITIVE = /([가-힣]+)의(?=[\s,.)\]]|$)/g;
+/** 관형격 조사 의. 영문과 숫자 뒤 (API의, 600MiB의) 와 닫는 괄호 뒤 (L7(HTTP)의) 도 센다. 파이썬 tokenize.py 와 같다. */
+const GENITIVE = /([가-힣A-Za-z0-9]+|\))의(?=[\s,.)\]]|$)/g;
 const SPACED_GENITIVE = /(?<=\s)의(?=\s)/g;
 const COPULA = /^(?:이(?:고|며|다|라|란|면|라서|므로|지만|어서|었다|었고)|인|인데|입니다|였다)$/;
 const DIGITS = /^\d+$/;
+/** 수에 단위가 붙은 어절 (2012년, 30분쯤, 제16호, 100명). 수량이라 명사 나열에서 세지도 끊지도 않는다. */
+const QUANTITY = /^제?\d[\d,.]*[가-힣]{1,3}$/;
 const OPENERS = "([{\"“‘'";
 const CLOSERS = ",.?!;:)]}\"”’'";
 const EDGE_PUNCTUATION = ".,?!:;\"'“”‘’()[]{}<>";
@@ -58,11 +62,39 @@ export function numerals() {
   return numeralCache;
 }
 
+/** @type {Set<string> | null} */
+let nonNounCache = null;
+export function nonNouns() {
+  if (!nonNounCache) nonNounCache = new Set(loadLines("nonNouns.txt"));
+  return nonNounCache;
+}
+
+/** @type {Set<string> | null} */
+let inNounCache = null;
+export function inNouns() {
+  if (!inNounCache) inNounCache = new Set(loadLines("inNouns.txt"));
+  return inNounCache;
+}
+
+/**
+ * `도구인`, `규모인` 처럼 명사에 계사 관형형 인 이 붙은 어절. 서술어라 명사 나열을 끊는다. 어간이 두 음절 이상일 때만이고
+ * 외국인 같은 세 음절 명사는 data/inNouns.txt 가 뺀다. 파이썬 tokenize.py 와 같다.
+ * @param {string} core
+ */
+export function isCopulaAdnominal(core) {
+  return core.length >= 3 && core.endsWith("인") && HANGUL_WORD.test(core) && !inNouns().has(core);
+}
+
 /** @param {string} core */
 export function isNumeral(core) {
   return numerals().has(core) || DIGITS.test(core);
 }
 
+/** 단위가 붙은 수. 수사와 달리 뒤 어절을 단위로 삼지 않는다. @param {string} core */
+export function isQuantity(core) {
+  return QUANTITY.test(core);
+}
+
 /** @param {string} text @returns {Word[]} */
 export function words(text) {
   return splitWords(text).map((raw) => {
@@ -93,7 +125,11 @@ export function isBareNoun(core) {
   return tailOf(core, "josa.txt") === null && tailOf(core, "verbTails.txt") === null;
 }
 
-/** 명사 어절 연속의 최대 길이. @param {string} text */
+/**
+ * 명사 어절 연속의 최대 길이. 의존명사와 관형사와 부사 (`수`, `몇`, `직접`) 는 조사도 어미도 안 붙어
+ * 표층으로는 명사로 보이지만 명사 쌓기의 재료가 아니다. data/nonNouns.txt 가 그 목록이고 연속을 끊는다.
+ * @param {string} text
+ */
 export function longestNounRun(text) {
   let longest = 0;
   let run = 0;
@@ -104,9 +140,9 @@ export function longestNounRun(text) {
       run = 0;
       previousAscii = false;
     }
-    const transparent = isNumeral(word.core) || afterNumeral;
+    const transparent = isNumeral(word.core) || afterNumeral || isQuantity(word.core);
     afterNumeral = isNumeral(word.core);
-    if (word.particle || !isBareNoun(word.core)) {
+    if (word.particle || nonNouns().has(word.core) || !isBareNoun(word.core) || isCopulaAdnominal(word.core)) {
       run = 0;
       previousAscii = false;
     } else if (!transparent) {
@@ -123,13 +159,26 @@ export function longestNounRun(text) {
   return longest;
 }
 
-/** 관형격 조사 의 의 수. @param {string} text */
-export function euiCount(text) {
-  let attached = 0;
+/** 관형격 조사 의 가 붙은 자리 [시작, 끝]. 정의, 회의 처럼 의 로 끝나는 낱말은 빼고 띄어 쓴 의 는 넣는다. @param {string} text @returns {[number, number][]} */
+export function genitiveSpans(text) {
+  /** @type {[number, number][]} */
+  const spans = [];
   for (const match of text.matchAll(GENITIVE)) {
-    if (!euiNouns().has(`${match[1]}의`)) attached += 1;
+    if (!euiNouns().has(match[1] + "의")) spans.push([/** @type {number} */ (match.index), /** @type {number} */ (match.index) + match[0].length]);
   }
-  return attached + [...text.matchAll(SPACED_GENITIVE)].length;
+  for (const match of text.matchAll(SPACED_GENITIVE)) spans.push([/** @type {number} */ (match.index), /** @type {number} */ (match.index) + match[0].length]);
+  return spans.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+}
+
+/** 의 로 끝나는 어절 둘이 붙어 있는가 (회사의 팀의). 사이가 공백뿐이어야 한다. @param {string} text */
+export function euiAdjacent(text) {
+  const spans = genitiveSpans(text);
+  return spans.some((span, index) => index > 0 && /^\s+$/.test(text.slice(spans[index - 1][1], span[0])));
+}
+
+/** 관형격 조사 의 의 수. @param {string} text */
+export function euiCount(text) {
+  return genitiveSpans(text).length;
 }
 
 /** 초성과 중성이 정해진 한글 음절 28개의 정규식 범위. @param {number} initial @param {number} vowel */
@@ -156,7 +205,15 @@ export function doublePassivePattern() {
   return passivePattern;
 }
 
+/** 이중 피동의 [시작, 끝, `되어지` 꼴 표층형]. @param {string} text @returns {[number, number, string][]} */
+export function doublePassiveSpans(text) {
+  return [...text.matchAll(doublePassivePattern())].map((match) => {
+    const start = /** @type {number} */ (match.index);
+    return [start, start + match[0].length, `${match[1]}지`];
+  });
+}
+
 /** 이중 피동의 표층형을 `되어지` 꼴로. @param {string} text */
 export function doublePassives(text) {
-  return [...text.matchAll(doublePassivePattern())].map((match) => `${match[1]}지`);
+  return doublePassiveSpans(text).map(([, , surface]) => surface);
 }

package/src/baseline/store.js

@@ -0,0 +1,114 @@
+// @ts-check
+/**
+ * 이미 있는 지적을 잠가 두고 새로 생긴 것만 막는다. 파이썬 `hanlint/baseline/store.py` 의 투영이다.
+ * 왜 줄 번호가 아니라 글자인지, 왜 사람이 읽는 꼴인지는 그 파일의 docstring 이 정본이다.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, posix, relative, resolve, sep } from "node:path";
+
+/** 기본 파일 이름. 저장소에 커밋해서 팀이 함께 본다. */
+export const DEFAULT_NAME = ".hanlint-baseline.json";
+export const VERSION = 1;
+
+/** 줄바꿈과 이어진 공백을 하나로 눕힌다. @param {string} quote */
+export function normalizeQuote(quote) {
+  return quote.split(/\s+/).filter(Boolean).join(" ");
+}
+
+/** @param {import("../rules/finding.js").Finding} finding */
+export function keyOf(finding) {
+  return `${finding.rule}\u0000${normalizeQuote(finding.quote)}`;
+}
+
+/** 잠금 파일이 있는 폴더 기준의 상대 경로. @param {string} path @param {string | null} target */
+export function pathKey(path, target) {
+  if (!target || !path || path.startsWith("<")) return path;
+  return relative(dirname(resolve(target)), resolve(path)).split(sep).join(posix.sep);
+}
+
+export class Baseline {
+  /** @param {Map<string, Set<string>>} [locked] @param {string | null} [source] */
+  constructor(locked = new Map(), source = null) {
+    this.locked = locked;
+    this.source = source;
+  }
+
+  get count() {
+    let total = 0;
+    for (const entries of this.locked.values()) total += entries.size;
+    return total;
+  }
+
+  /** @param {string} path @param {import("../rules/finding.js").Finding} finding */
+  isLocked(path, finding) {
+    return (this.locked.get(pathKey(path, this.source)) ?? new Set()).has(keyOf(finding));
+  }
+
+  /** 잠기지 않은 지적만 남긴다. @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
+  keep(path, findings) {
+    return findings.filter((finding) => !this.isLocked(path, finding));
+  }
+}
+
+/** @param {Map<string, import("../rules/finding.js").Finding[]>} results @param {string | null} [target] */
+export function build(results, target = null) {
+  /** @type {Map<string, Set<string>>} */
+  const locked = new Map();
+  for (const [path, findings] of results) {
+    if (findings.length) locked.set(pathKey(path, target), new Set(findings.map(keyOf)));
+  }
+  return new Baseline(locked, target ? resolve(target) : null);
+}
+
+/** 사람이 읽고 리뷰하는 꼴. 정렬해 담아 같은 입력에 같은 파일이 나온다. @param {Baseline} baseline */
+export function render(baseline) {
+  /** @type {Record<string, {rule: string, quote: string}[]>} */
+  const files = {};
+  let locked = 0;
+  for (const path of [...baseline.locked.keys()].sort()) {
+    const entries = [...(baseline.locked.get(path) ?? [])].sort();
+    if (!entries.length) continue;
+    files[path] = entries.map((entry) => {
+      const [rule, quote] = entry.split("\u0000");
+      return { rule, quote };
+    });
+    locked += entries.length;
+  }
+  return JSON.stringify({ version: VERSION, locked, files }, null, 2);
+}
+
+/** @param {string} text @param {string | null} [source] */
+export function parse(text, source = null) {
+  const data = JSON.parse(text);
+  if (data.version !== VERSION) throw new Error(`모르는 baseline 판 ${data.version}. hanlint baseline 으로 다시 만든다`);
+  /** @type {Map<string, Set<string>>} */
+  const locked = new Map();
+  for (const [path, entries] of Object.entries(data.files ?? {})) {
+    locked.set(path, new Set(/** @type {{rule: string, quote: string}[]} */ (entries).map((e) => `${e.rule}\u0000${e.quote}`)));
+  }
+  return new Baseline(locked, source);
+}
+
+/** @param {string} path */
+export function load(path) {
+  if (!existsSync(path)) {
+    const error = /** @type {NodeJS.ErrnoException} */ (new Error(`${path} 를 찾지 못했다`));
+    error.code = "ENOENT";
+    error.path = path;
+    throw error;
+  }
+  return parse(readFileSync(path, "utf-8"), resolve(path));
+}
+
+/** 지금 글에 더 없는 잠금을 지운다. @param {Baseline} baseline @param {Map<string, import("../rules/finding.js").Finding[]>} results */
+export function prune(baseline, results) {
+  const kept = new Map(baseline.locked);
+  for (const [path, findings] of results) {
+    const key = pathKey(path, baseline.source);
+    const present = new Set(findings.map(keyOf));
+    const remaining = new Set([...(kept.get(key) ?? [])].filter((entry) => present.has(entry)));
+    if (remaining.size) kept.set(key, remaining);
+    else kept.delete(key);
+  }
+  return new Baseline(kept, baseline.source);
+}