hanlint 0.0.7 → 0.0.8

package/src/data/operations.js

@@ -0,0 +1,278 @@
+// @ts-check
+/** 승인 고침에서 뜻을 추측하지 않고 재사용할 수 있는 표면 치환. 파이썬 data/operations.py와 같다. */
+
+const URL_PATTERN = /https?:\/\/[^\s)>\]]*[\p{L}\p{N}_/#=%&+~-]/gu;
+const NUMBER_PATTERN = /(?<![A-Za-z가-힣])[-+]?\d+(?:[.,:]\d+)*(?:%|[가-힣]+)?/gu;
+const LATIN_PATTERN = /(?<![A-Za-z0-9_])(?:[A-Za-z_][A-Za-z0-9_.:/<>-]*)(?![A-Za-z0-9_])/gu;
+// 파이썬 `re` 의 `\w` 는 유니코드라 한글을 담지만 JS 의 `\w` 는 /u 를 붙여도 ASCII 뿐이다. 그대로 두면
+// docs/렌더/index.md 를 파이썬만 경로 원자로 보고 npm 은 그 안을 치환해 버린다 (말뭉치 실문장
+// 32,274개에서 280건이 갈렸다). URL_PATTERN 이 이미 쓰는 표기로 맞춘다.
+const WORD = "[\\p{L}\\p{N}_]";
+const PATH_PATTERN = new RegExp(
+  `(?<!${WORD})(?:[\\p{L}\\p{N}_.-]+/)+[\\p{L}\\p{N}_.-]+|(?<!${WORD})[\\p{L}\\p{N}_-]+\\.[A-Za-z0-9]{1,8}(?!${WORD})`,
+  "gu",
+);
+const INLINE_CODE_PATTERN = /`([^`\n]+)`/gu;
+// d 플래그로 진짜 그룹 시작을 읽는다. indexOf 로 찾으면 [렌더](렌더) 처럼 링크 글자와 목적지가 같을 때
+// 링크 글자 쪽을 목적지로 착각한다. 파이썬은 match.start(1) 을 쓴다.
+const LINK_DESTINATION_PATTERN = /\[[^\u005D]*\]\(([^)]+)\)/gdu;
+const HTML_TAG_PATTERN = /<[^>\n]+>/gu;
+const DEICTIC_FRAGMENT = /이것|그것|저것|이러한|그러한|해당|이는|그는|그녀|그들/u;
+const SURFACE_CHARACTER = /[가-힣A-Za-z0-9]/gu;
+const BOUNDARY = new Set(` \t\r\n,.;:!?()[]{}<>"'“”‘’…·/\\|+=*`);
+export const MAX_FRAGMENT_CHARACTERS = 32;
+export const MAX_SURFACE_EDIT_DISTANCE = 1;
+
+/**
+ * @typedef {object} SurfaceOperation
+ * @property {string} before
+ * @property {string} after
+ * @property {string[]} presets
+ */
+
+/** @param {string} text */
+export function protectedAtoms(text) {
+  const found = [];
+  for (const [pattern, label, group] of [
+    [URL_PATTERN, "url", 0],
+    [NUMBER_PATTERN, "number", 0],
+    [LATIN_PATTERN, "latin", 0],
+    [PATH_PATTERN, "path", 0],
+    [INLINE_CODE_PATTERN, "code", 1],
+    [LINK_DESTINATION_PATTERN, "link", 1],
+  ]) {
+    for (const match of text.matchAll(/** @type {RegExp} */ (pattern))) {
+      found.push(`${label}:${match[/** @type {number} */ (group)]}`);
+    }
+  }
+  return found.sort();
+}
+
+/** @param {string} text */
+export function protectedSpans(text) {
+  const spans = [];
+  for (const pattern of [INLINE_CODE_PATTERN, URL_PATTERN, HTML_TAG_PATTERN]) {
+    for (const match of text.matchAll(pattern)) spans.push([match.index, match.index + match[0].length]);
+  }
+  for (const match of text.matchAll(LINK_DESTINATION_PATTERN)) {
+    const [start, end] = /** @type {RegExpIndicesArray} */ (match.indices)[1];
+    spans.push([start, end]);
+  }
+  // 파이썬은 sorted(set(spans)) 라 겹친 구간을 한 번만 둔다 (코드 안의 URL 처럼).
+  const unique = [...new Map(spans.map((span) => [`${span[0]}:${span[1]}`, span])).values()];
+  return unique.sort((left, right) => left[0] - right[0] || left[1] - right[1]);
+}
+
+/** @param {string} text @param {string[]} terms */
+export function protectedTermAtoms(text, terms) {
+  const found = [];
+  for (const term of terms) {
+    let cursor = 0;
+    while (term) {
+      const at = text.indexOf(term, cursor);
+      if (at < 0) break;
+      found.push(term);
+      cursor = at + term.length;
+    }
+  }
+  return found.sort();
+}
+
+/** @param {string} text @param {number} at */
+function startBoundary(text, at) {
+  while (at > 0 && !BOUNDARY.has(text[at - 1])) at -= 1;
+  return at;
+}
+
+/** @param {string} text @param {number} at */
+function endBoundary(text, at) {
+  while (at < text.length && !BOUNDARY.has(text[at])) at += 1;
+  return at;
+}
+
+/** @param {string} before @param {string} after */
+export function changedFragment(before, after) {
+  let prefix = 0;
+  const limit = Math.min(before.length, after.length);
+  while (prefix < limit && before[prefix] === after[prefix]) prefix += 1;
+  let suffix = 0;
+  const remaining = Math.min(before.length - prefix, after.length - prefix);
+  while (suffix < remaining && before[before.length - suffix - 1] === after[after.length - suffix - 1]) suffix += 1;
+  const start = startBoundary(before, prefix);
+  const beforeEnd = endBoundary(before, before.length - suffix);
+  const afterEnd = endBoundary(after, after.length - suffix);
+  return [before.slice(start, beforeEnd).trim(), after.slice(start, afterEnd).trim()];
+}
+
+/** @param {string} left @param {string} right */
+export function editDistance(left, right) {
+  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+    const current = [leftIndex];
+    for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) {
+      current.push(
+        Math.min(
+          current[current.length - 1] + 1,
+          previous[rightIndex] + 1,
+          previous[rightIndex - 1] + Number(left[leftIndex - 1] !== right[rightIndex - 1]),
+        ),
+      );
+    }
+    previous = current;
+  }
+  return previous[previous.length - 1];
+}
+
+/** @param {string} text */
+export function surfaceSkeleton(text) {
+  return [...text.matchAll(SURFACE_CHARACTER)].map((match) => match[0]).join("");
+}
+
+/**
+ * 승인 전후 전체에서 기계가 보증할 수 있는 표면 치환 하나를 추출한다.
+ * @param {string} before @param {string} after @param {string[]} [presets] @param {string[]} [protectedTerms]
+ * @returns {SurfaceOperation | undefined}
+ */
+export function operationFromApproval(before, after, presets = [], protectedTerms = []) {
+  before = before.normalize("NFC");
+  after = after.normalize("NFC");
+  if (
+    JSON.stringify(protectedAtoms(before)) !== JSON.stringify(protectedAtoms(after)) ||
+    JSON.stringify(protectedTermAtoms(before, protectedTerms)) !== JSON.stringify(protectedTermAtoms(after, protectedTerms))
+  ) {
+    return undefined;
+  }
+  const [beforeFragment, afterFragment] = changedFragment(before, after);
+  const beforeSkeleton = surfaceSkeleton(beforeFragment);
+  const afterSkeleton = surfaceSkeleton(afterFragment);
+  if (
+    !beforeFragment ||
+    !afterFragment ||
+    beforeFragment === afterFragment ||
+    beforeFragment.length > MAX_FRAGMENT_CHARACTERS ||
+    afterFragment.length > MAX_FRAGMENT_CHARACTERS ||
+    beforeSkeleton.length < 2 ||
+    afterSkeleton.length < 2 ||
+    editDistance(beforeSkeleton, afterSkeleton) > MAX_SURFACE_EDIT_DISTANCE ||
+    DEICTIC_FRAGMENT.test(beforeFragment) ||
+    DEICTIC_FRAGMENT.test(afterFragment) ||
+    protectedTerms.some((term) => beforeFragment.includes(term) || afterFragment.includes(term)) ||
+    protectedAtoms(beforeFragment).length ||
+    protectedAtoms(afterFragment).length ||
+    before.split(beforeFragment).length - 1 !== 1
+  ) {
+    return undefined;
+  }
+  return { before: beforeFragment, after: afterFragment, presets: [...presets] };
+}
+
+/** @param {unknown} entries @param {string[]} presetNames @returns {SurfaceOperation[]} */
+export function projectOperations(entries, presetNames) {
+  if (!Array.isArray(entries)) throw new Error("operations 는 [[operations]] 배열이다");
+  const knownPresets = new Set(presetNames);
+  const selectors = new Set();
+  return entries.map((raw, offset) => {
+    const index = offset + 1;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`operations ${index}번째 항목은 표다`);
+    const entry = /** @type {Record<string, unknown>} */ (raw);
+    const unknown = Object.keys(entry).filter((key) => !["before", "after", "presets"].includes(key)).sort();
+    if (unknown.length) throw new Error(`operations ${index}번째 항목의 모르는 키: ${unknown.join(", ")}`);
+    const before = entry.before;
+    const after = entry.after;
+    if (typeof before !== "string" || !before.trim() || before !== before.trim()) {
+      throw new Error(`operations ${index}번째 항목의 before 는 양끝 공백 없는 문자열이다`);
+    }
+    if (typeof after !== "string" || !after.trim() || after !== after.trim()) {
+      throw new Error(`operations ${index}번째 항목의 after 는 양끝 공백 없는 문자열이다`);
+    }
+    const rawPresets = entry.presets;
+    if (!Array.isArray(rawPresets) || !rawPresets.length || !rawPresets.every((item) => typeof item === "string")) {
+      throw new Error(`operations ${index}번째 항목의 presets 는 비지 않은 문자열 배열이다`);
+    }
+    const presets = /** @type {string[]} */ (rawPresets);
+    const unknownPresets = [...new Set(presets.filter((preset) => !knownPresets.has(preset)))].sort();
+    if (unknownPresets.length) throw new Error(`operations ${index}번째 항목의 모르는 프리셋: ${unknownPresets.join(", ")}`);
+    if (new Set(presets).size !== presets.length) throw new Error(`operation의 프리셋이 겹친다: ${before}`);
+    const operation = operationFromApproval(before, after, presets);
+    if (!operation || operation.before !== before || operation.after !== after) {
+      throw new Error(`operations ${index}번째 항목은 안전한 표면 치환이 아니다: ${before} -> ${after}`);
+    }
+    for (const preset of presets) {
+      const selector = JSON.stringify([preset, before]);
+      if (selectors.has(selector)) throw new Error(`operation 선택 조건이 겹친다: ${preset} ${before}`);
+      selectors.add(selector);
+    }
+    return operation;
+  });
+}
+
+/** @param {string} character */
+function wordCharacter(character) {
+  return Boolean(character) && /[\p{L}\p{N}_]/u.test(character);
+}
+
+/** @param {string} text @param {SurfaceOperation} operation @param {string[]} [protectedTerms] */
+export function operationPositions(text, operation, protectedTerms = []) {
+  const positions = [];
+  const blocked = protectedSpans(text);
+  for (const term of protectedTerms) {
+    let cursor = 0;
+    while (term) {
+      const at = text.indexOf(term, cursor);
+      if (at < 0) break;
+      blocked.push([at, at + term.length]);
+      cursor = at + term.length;
+    }
+  }
+  let cursor = 0;
+  while (true) {
+    const at = text.indexOf(operation.before, cursor);
+    if (at < 0) return positions;
+    const end = at + operation.before.length;
+    const left = at > 0 ? text[at - 1] : "";
+    const right = end < text.length ? text[end] : "";
+    const touchesWord =
+      (wordCharacter(operation.before[0]) && wordCharacter(left)) ||
+      (wordCharacter(operation.before[operation.before.length - 1]) && wordCharacter(right));
+    const insideProtected = blocked.some(([start, stop]) => at < stop && end > start);
+    if (!touchesWord && !insideProtected) positions.push(at);
+    cursor = at + 1;
+  }
+}
+
+/** @param {string} text @param {SurfaceOperation} operation @param {string[]} [protectedTerms] */
+export function applyOperation(text, operation, protectedTerms = []) {
+  const positions = operationPositions(text, operation, protectedTerms);
+  if (positions.length !== 1) return undefined;
+  const at = positions[0];
+  const end = at + operation.before.length;
+  const changed = text.slice(0, at) + operation.after + text.slice(end);
+  const factsPreserved = JSON.stringify(protectedAtoms(text)) === JSON.stringify(protectedAtoms(changed));
+  const termsPreserved =
+    JSON.stringify(protectedTermAtoms(text, protectedTerms)) === JSON.stringify(protectedTermAtoms(changed, protectedTerms));
+  return factsPreserved && termsPreserved ? changed : undefined;
+}
+
+/** @param {string} sourceText @param {string | null | undefined} preset @param {SurfaceOperation[]} operations @param {string[]} [protectedTerms] */
+export function operationFor(sourceText, preset, operations, protectedTerms = []) {
+  if (!preset) return undefined;
+  const matches = [];
+  for (const operation of operations) {
+    if (!operation.presets.includes(preset)) continue;
+    const result = applyOperation(sourceText, operation, protectedTerms);
+    if (result !== undefined) matches.push({ operation, sourceText, result });
+  }
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
+/** @param {{operation: SurfaceOperation, sourceText: string, result: string}} applied @param {string} preset */
+export function operationData(applied, preset) {
+  return {
+    kind: "surfaceSubstitution",
+    before: applied.operation.before,
+    after: applied.operation.after,
+    sourceText: applied.sourceText,
+    result: applied.result,
+    match: { preset, unique: true, wordBoundary: true, protectedFacts: true },
+  };
+}

package/src/data/patches.js

@@ -0,0 +1,125 @@
+// @ts-check
+/** 글쓴이가 승인한 원문 완전 일치 고침. 파이썬 data/patches.py와 같은 선택 계약이다. */
+import { exemplars, expand } from "./exemplars.js";
+
+export const READER_KINDS = ["recent", "known", "new", "none"];
+
+/**
+ * @typedef {object} Patch
+ * @property {string} rule
+ * @property {string} before
+ * @property {string} after
+ * @property {string} moved
+ * @property {string} cue
+ * @property {string} reader
+ * @property {string[]} presets
+ * @property {string} sentence 마크다운 표식을 걷은 선택용 원문
+ * @property {string} sourceText 마크다운 표식을 보존한 선택용 원문
+ */
+
+/** 줄과 연속 공백 차이는 선택 조건으로 쓰지 않는다. @param {string} text */
+export function flatCue(text) {
+  return text.split(/\s+/).filter(Boolean).join(" ");
+}
+
+/** 승인 원문은 유니코드 조합과 줄, 연속 공백만 눕혀 비교한다. @param {string} text */
+export function flatSentence(text) {
+  return text.normalize("NFC").split(/\s+/).filter(Boolean).join(" ");
+}
+
+/** 설정의 `[[patches]]`를 검증한다. @param {unknown} entries @param {string[]} presetNames @returns {Patch[]} */
+export function projectPatches(entries, presetNames) {
+  if (!Array.isArray(entries)) throw new Error("patches 는 [[patches]] 배열이다");
+  const allowedKeys = new Set(["rule", "before", "after", "moved", "sourceText", "sentence", "cue", "reader", "presets"]);
+  const knownRules = new Set(exemplars().keys());
+  const knownPresets = new Set(presetNames);
+  const selectors = new Set();
+  return entries.map((raw, offset) => {
+    const index = offset + 1;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`patches ${index}번째 항목은 표다`);
+    const entry = /** @type {Record<string, unknown>} */ (raw);
+    const unknown = Object.keys(entry).filter((key) => !allowedKeys.has(key)).sort();
+    if (unknown.length) throw new Error(`patches ${index}번째 항목의 모르는 키: ${unknown.join(", ")}`);
+    /** @type {Record<string, string>} */
+    const values = {};
+    for (const key of ["rule", "before", "after", "moved", "cue", "reader"]) {
+      const value = entry[key];
+      if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`patches ${index}번째 항목의 ${key} 는 비지 않은 문자열이다`);
+      }
+      values[key] = value;
+    }
+    const rule = values.rule;
+    if (!knownRules.has(rule)) throw new Error(`patches ${index}번째 항목의 모르는 규칙: ${rule}`);
+    const reader = values.reader;
+    if (!READER_KINDS.includes(reader)) {
+      throw new Error(`patches ${index}번째 항목의 reader 는 ${READER_KINDS.join(", ")} 가운데 하나다: ${reader}`);
+    }
+    const rawPresets = entry.presets;
+    if (!Array.isArray(rawPresets) || !rawPresets.length || !rawPresets.every((item) => typeof item === "string")) {
+      throw new Error(`patches ${index}번째 항목의 presets 는 비지 않은 문자열 배열이다`);
+    }
+    const presets = /** @type {string[]} */ (rawPresets);
+    const unknownPresets = [...new Set(presets.filter((preset) => !knownPresets.has(preset)))].sort();
+    if (unknownPresets.length) {
+      throw new Error(`patches ${index}번째 항목의 모르는 프리셋: ${unknownPresets.join(", ")}`);
+    }
+    if (new Set(presets).size !== presets.length) throw new Error(`패치의 프리셋이 겹친다: ${rule}`);
+    const cue = flatCue(values.cue);
+    const before = expand(values.before);
+    const after = expand(values.after);
+    const rawSentence = entry.sentence ?? before;
+    if (typeof rawSentence !== "string" || !rawSentence.trim()) {
+      throw new Error(`patches ${index}번째 항목의 sentence 는 비지 않은 문자열이다`);
+    }
+    const sentence = flatSentence(rawSentence);
+    const rawSourceText = entry.sourceText ?? before;
+    if (typeof rawSourceText !== "string" || !rawSourceText.trim()) {
+      throw new Error(`patches ${index}번째 항목의 sourceText 는 비지 않은 문자열이다`);
+    }
+    const sourceText = flatSentence(rawSourceText);
+    for (const preset of presets) {
+      const selector = JSON.stringify([rule, preset, sourceText, sentence, cue, reader]);
+      if (selectors.has(selector)) throw new Error(`패치 선택 조건이 겹친다: ${rule} ${preset} ${cue} ${reader}`);
+      selectors.add(selector);
+    }
+    return {
+      rule,
+      before,
+      after,
+      moved: values.moved,
+      cue,
+      reader,
+      presets,
+      sentence,
+      sourceText,
+    };
+  });
+}
+
+/**
+ * 원문을 포함한 모든 조건이 맞는 패치가 하나일 때만 돌려준다.
+ * @param {string} rule
+ * @param {string | null | undefined} preset
+ * @param {string} sourceText
+ * @param {string} sentence
+ * @param {string} cue
+ * @param {string | null | undefined} reader
+ * @param {Patch[]} patches
+ */
+export function patchFor(rule, preset, sourceText, sentence, cue, reader, patches) {
+  if (!preset || !reader || !READER_KINDS.includes(reader)) return undefined;
+  const wantedCue = flatCue(cue);
+  const wantedSourceText = flatSentence(sourceText);
+  const wantedSentence = flatSentence(sentence);
+  const matches = patches.filter(
+    (patch) =>
+      patch.rule === rule &&
+      patch.presets.includes(preset) &&
+      patch.sourceText === wantedSourceText &&
+      patch.sentence === wantedSentence &&
+      patch.cue === wantedCue &&
+      patch.reader === reader,
+  );
+  return matches.length === 1 ? matches[0] : undefined;
+}

package/src/data/patterns.js

@@ -0,0 +1,48 @@
+// @ts-check
+/**
+ * 문형. 빈칸이 있는 문장 틀. 파이썬 data/patterns.py 와 같다.
+ * 본보기가 고친 사례 하나라면 문형은 그 사례를 다시 쓸 수 있는 틀이다.
+ */
+import { loadEntries } from "./load.js";
+
+/**
+ * @typedef {object} Pattern
+ * @property {string} name
+ * @property {string} form 빈칸이 있는 틀
+ * @property {string} when 이 틀을 꺼내는 자리
+ * @property {string} example 그 틀로 쓴 문장. hanlint 를 통과한다
+ * @property {string} instead 같은 자리에 흔히 쓰는 문장. avoids 의 규칙에 잡힌다
+ * @property {string[]} avoids
+ * @property {string} source
+ */
+
+/** @type {Pattern[] | null} */
+let cache = null;
+
+/** @returns {Pattern[]} */
+export function patterns() {
+  if (!cache) {
+    cache = [];
+    const seen = new Set();
+    for (const entry of loadEntries("patterns.json")) {
+      const name = /** @type {string} */ (entry.name);
+      if (seen.has(name)) throw new Error(`문형 이름이 겹친다: ${name}`);
+      seen.add(name);
+      cache.push({
+        name,
+        form: /** @type {string} */ (entry.form),
+        when: /** @type {string} */ (entry.when),
+        example: /** @type {string} */ (entry.example),
+        instead: /** @type {string} */ (entry.instead),
+        avoids: /** @type {string[]} */ (entry.avoids),
+        source: /** @type {string} */ (entry.source),
+      });
+    }
+  }
+  return cache;
+}
+
+/** 그 규칙을 피하는 문형들. @param {string} rule */
+export function patternsAvoiding(rule) {
+  return patterns().filter((pattern) => pattern.avoids.includes(rule));
+}

package/src/data/profiles.js

@@ -0,0 +1,102 @@
+// @ts-check
+/**
+ * 참조 분포 (프로파일) 의 자료형과 읽기. 파이썬 data/profiles.py 와 같다. 종류별 프로파일은 profiles.json (투영) 에서,
+ * 사용자 프로파일은 `hanlint profile build` 가 만든 파일에서 읽는다. 히스토그램은 정확한 계수라 두 판의 셈이 같다.
+ */
+import { readFileSync } from "node:fs";
+
+import { readText } from "./load.js";
+
+export const PROFILE_VERSION = 1;
+/** 히스토그램의 상한. 이 값보다 큰 것은 상한에 합친다. */
+export const CAP = 200;
+const PERCENTILES = [50, 90, 95, 99];
+/** 기준 말뭉치 종류의 이름. 지적문에 적는다. 파이썬 TYPE_LABELS 와 같다. @type {Record<string, string>} */
+export const TYPE_LABELS = {
+  blog: "블로그",
+  technicalDocs: "기술 문서",
+  guide: "안내서",
+  report: "뉴스와 보고문",
+  essay: "수필 (1930년대)",
+  fiction: "소설 (1930년대)",
+  encyclopedia: "백과",
+};
+
+/**
+ * @typedef {object} Histogram
+ * @property {number} total
+ * @property {Map<number, number>} counts 값 → 수
+ * @property {Map<number, number>} percentiles 백분위 → 값
+ */
+
+/**
+ * @typedef {object} Profile
+ * @property {string} kind
+ * @property {number} documents
+ * @property {number} sentences
+ * @property {number} paragraphs
+ * @property {Map<string, Histogram>} sentence
+ * @property {string} label
+ */
+
+/** @param {Record<string, unknown>} data @returns {Histogram} */
+function histogramFromDict(data) {
+  const counts = new Map();
+  for (const [value, count] of Object.entries(/** @type {Record<string, number>} */ (data.counts))) counts.set(Number(value), Number(count));
+  const percentiles = new Map();
+  for (const p of PERCENTILES) if (`p${p}` in data) percentiles.set(p, Number(data[`p${p}`]));
+  return { total: Number(data.total), counts, percentiles };
+}
+
+/** 값이 이 이상인 것의 몫을 천분율 정수로. 정수 셈이라 두 판의 글자가 같다. @param {Histogram} hist @param {number} value */
+export function shareAtOrAbove(hist, value) {
+  const capped = Math.min(value, CAP);
+  let above = 0;
+  for (const [seen, count] of hist.counts) if (seen >= capped) above += count;
+  return hist.total ? Math.floor((above * 1000) / hist.total) : 0;
+}
+
+/** @param {string} kind @param {Record<string, unknown>} data @returns {Profile} */
+function profileFromDict(kind, data) {
+  const sentence = new Map();
+  for (const [name, value] of Object.entries(/** @type {Record<string, Record<string, unknown>>} */ (data.sentence))) {
+    sentence.set(name, histogramFromDict(value));
+  }
+  const documents = Number(data.documents);
+  return {
+    kind,
+    documents,
+    sentences: Number(data.sentences),
+    paragraphs: Number(data.paragraphs),
+    sentence,
+    label: TYPE_LABELS[kind] ?? `참조 글 ${documents}편`,
+  };
+}
+
+/** @type {Map<string, Profile> | null} */
+let shipped = null;
+/** hanlint 가 싣는 종류별 프로파일. @param {string} kind @returns {Profile | null} */
+export function profileOf(kind) {
+  if (!shipped) {
+    shipped = new Map();
+    const data = JSON.parse(readText("profiles.json"));
+    for (const [name, value] of Object.entries(data.types)) shipped.set(name, profileFromDict(name, value));
+  }
+  return shipped.get(kind) ?? null;
+}
+
+/** @type {Map<string, Profile>} */
+const users = new Map();
+/** 사용자 프로파일 파일. 한 번 읽은 것은 기억한다. @param {string} path @returns {Profile} */
+export function userProfile(path) {
+  let profile = users.get(path);
+  if (!profile) {
+    const data = JSON.parse(readFileSync(path, "utf-8"));
+    if (data.version !== PROFILE_VERSION || !("profile" in data)) {
+      throw new Error(`프로파일 파일이 아니다: ${path}. hanlint profile build 로 다시 만든다`);
+    }
+    profile = profileFromDict("custom", data.profile);
+    users.set(path, profile);
+  }
+  return profile;
+}

package/src/document/model.js

@@ -7,6 +7,7 @@
 export const PROSE = "prose";
 export const HEADING = "heading";
 export const CODE = "code";
+export const QUOTE = "quote";
 export const IMAGE = "image";
 export const LIST = "list";
 export const TABLE = "table";
@@ -36,6 +37,7 @@ export const HTML = "html";
  * @property {Block[]} blocks
  * @property {Section[]} sections
  * @property {[string, number, number][]} disabled 인라인 제어가 끈 (규칙 또는 *, 시작 줄, 끝 줄)
+ * @property {Block[]} ignored 설정이 지문에서 뺀 펜스. 파일 전체를 보는 규칙만 읽는다
  */
 
 /** @param {Section} section */