hanlint 0.0.18 → 0.0.19

package/src/data/exemplars.js

@@ -1,18 +1,18 @@
 // @ts-check
 /**
- * 본보기. 규칙마다 고치기 전과 후의 짝. 파이썬 data/exemplars.py 와 같다.
+ * 예시. 규칙마다 고치기 전과 고친 뒤의 짝. 파이썬 data/exemplars.py와 같다.
  *
- * 지적은 무엇이 틀렸는지 말하고 본보기는 무엇이 맞는지 보인다. 자리표시자 규약은 fixture 와 같다.
- * `{em}` 은 긴 줄표, `{dot}` 은 마침표다.
+ * 지적은 무엇이 틀렸는지 말하고 예시는 무엇이 맞는지 보인다. 자리표시자 규칙은 fixture와 같다.
+ * `{em}`은 긴 줄표, `{dot}`은 마침표다.
  */
 import { loadEntries } from "./load.js";
 
 const EM_DASH = String.fromCharCode(0x2014);
 const EN_DASH = String.fromCharCode(0x2013);
 const ELLIPSIS_CHAR = String.fromCharCode(0x2026);
-/** 한 줄 본보기의 표시 폭 상한. 글자 수가 아니라 폭이다. 뜻은 파이썬 data/exemplars.py 가 소유한다. */
+/** 한 줄 예시의 표시 폭 상한. 글자 수가 아니라 폭이다. 까닭은 파이썬 data/exemplars.py에 적었다. */
 const ONE_LINE_LIMIT = 96;
-/** 칸을 둘 먹는 글자. 한중일 W 와 F 다. 파이썬 unicodedata.east_asian_width 와 같은 범위를 든다. */
+/** 두 칸을 차지하는 글자. 한중일 W와 F다. 파이썬 unicodedata.east_asian_width와 같은 범위다. */
 const WIDE = /[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF\uA000-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE6F\uFF00-\uFF60\uFFE0-\uFFE6]/;
 
 /**
@@ -21,7 +21,7 @@ const WIDE = /[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF
  * @property {string} before 그 규칙에 실제로 잡히는 글
  * @property {string} after 같은 뜻이면서 잡히지 않는 글
  * @property {string} moved 무엇이 달라졌는지 한 마디
- * @property {string[]} presets 비어 있으면 기본, 값이 있으면 그 프리셋의 문맥 본보기
+ * @property {string[]} presets 비어 있으면 기본, 값이 있으면 그 프리셋의 문맥 예시
  */
 
 /** @param {string} text */
@@ -29,14 +29,14 @@ export function expand(text) {
   return text.split("{em}").join(EM_DASH).split("{en}").join(EN_DASH).split("{dot}").join(".");
 }
 
-/** 터미널이 먹는 칸 수. 한중일 글자는 둘, 나머지는 하나다. @param {string} text */
+/** 터미널에서 차지하는 칸 수. 한중일 글자는 둘, 나머지는 하나다. @param {string} text */
 export function displayWidth(text) {
   let width = 0;
   for (const ch of text) width += WIDE.test(ch) ? 2 : 1;
   return width;
 }
 
-/** 한 줄로 보일 때의 꼴. 줄바꿈은 공백으로 눕히고 폭이 넘치면 자른다. @param {string} text @param {number} [limit] */
+/** 한 줄로 보일 때의 모양. 줄바꿈은 공백으로 바꾸고 폭이 넘치면 자른다. @param {string} text @param {number} [limit] */
 export function shorten(text, limit = ONE_LINE_LIMIT) {
   const flat = text.split(/\s+/).filter(Boolean).join(" ");
   if (displayWidth(flat) <= limit) return flat;
@@ -61,7 +61,7 @@ let allCache = null;
 /** @type {Map<string, Exemplar> | null} */
 let defaultCache = null;
 
-/** 기본과 문맥 본보기를 모두 읽는다. @returns {Exemplar[]} */
+/** 기본 예시와 문맥 예시를 모두 읽는다. @returns {Exemplar[]} */
 export function allExemplars() {
   if (!allCache) {
     allCache = [];
@@ -72,12 +72,12 @@ export function allExemplars() {
       const rule = /** @type {string} */ (entry.rule);
       const presets = /** @type {string[]} */ (entry.presets ?? []);
       if (!presets.length) {
-        if (defaults.has(rule)) throw new Error(`기본 본보기가 겹친다: ${rule}`);
+        if (defaults.has(rule)) throw new Error(`기본 예시가 겹친다: ${rule}`);
         defaults.add(rule);
       } else {
         const used = contexts.get(rule) ?? new Set();
         const overlap = presets.filter((preset) => used.has(preset)).sort();
-        if (overlap.length) throw new Error(`문맥 본보기의 프리셋이 겹친다: ${rule} ${overlap.join(", ")}`);
+        if (overlap.length) throw new Error(`문맥 예시의 프리셋이 겹친다: ${rule} ${overlap.join(", ")}`);
         for (const preset of presets) used.add(preset);
         contexts.set(rule, used);
       }
@@ -93,7 +93,7 @@ export function allExemplars() {
   return allCache;
 }
 
-/** 규칙 이름 → 본보기. @returns {Map<string, Exemplar>} */
+/** 규칙 이름 → 예시. @returns {Map<string, Exemplar>} */
 export function exemplars() {
   if (!defaultCache) {
     defaultCache = new Map(
@@ -103,9 +103,9 @@ export function exemplars() {
   return defaultCache;
 }
 
-/** 설정의 `[[exemplars]]` 를 검증한다. @param {unknown} entries @param {string[]} presetNames @returns {Exemplar[]} */
+/** 설정의 `[[exemplars]]`를 검증한다. @param {unknown} entries @param {string[]} presetNames @returns {Exemplar[]} */
 export function projectExemplars(entries, presetNames) {
-  if (!Array.isArray(entries)) throw new Error("exemplars 는 [[exemplars]] 배열이다");
+  if (!Array.isArray(entries)) throw new Error("exemplars는 [[exemplars]] 배열이어야 한다");
   const allowedKeys = new Set(["rule", "before", "after", "moved", "presets"]);
   const knownRules = new Set(exemplars().keys());
   const knownPresets = new Set(presetNames);
@@ -114,7 +114,7 @@ export function projectExemplars(entries, presetNames) {
   const contexts = new Map();
   return entries.map((raw, offset) => {
     const index = offset + 1;
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`exemplars ${index}번째 항목은 표다`);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`exemplars ${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(`exemplars ${index}번째 항목의 모르는 키: ${unknown.join(", ")}`);
@@ -123,7 +123,7 @@ export function projectExemplars(entries, presetNames) {
     for (const key of ["rule", "before", "after", "moved"]) {
       const value = entry[key];
       if (typeof value !== "string" || !value.trim()) {
-        throw new Error(`exemplars ${index}번째 항목의 ${key} 는 비지 않은 문자열이다`);
+        throw new Error(`exemplars ${index}번째 항목의 ${key} 값은 비지 않은 문자열이어야 한다`);
       }
       values[key] = value;
     }
@@ -131,21 +131,21 @@ export function projectExemplars(entries, presetNames) {
     if (!knownRules.has(rule)) throw new Error(`exemplars ${index}번째 항목의 모르는 규칙: ${rule}`);
     const rawPresets = entry.presets ?? [];
     if (!Array.isArray(rawPresets) || !rawPresets.every((item) => typeof item === "string")) {
-      throw new Error(`exemplars ${index}번째 항목의 presets 는 문자열 배열이다`);
+      throw new Error(`exemplars ${index}번째 항목의 presets는 문자열 배열이어야 한다`);
     }
     const presets = /** @type {string[]} */ (rawPresets);
     const unknownPresets = [...new Set(presets.filter((preset) => !knownPresets.has(preset)))].sort();
     if (unknownPresets.length) {
       throw new Error(`exemplars ${index}번째 항목의 모르는 프리셋: ${unknownPresets.join(", ")}`);
     }
-    if (new Set(presets).size !== presets.length) throw new Error(`프로젝트 본보기의 프리셋이 겹친다: ${rule}`);
+    if (new Set(presets).size !== presets.length) throw new Error(`프로젝트 예시의 프리셋이 겹친다: ${rule}`);
     if (!presets.length) {
-      if (defaults.has(rule)) throw new Error(`프로젝트 기본 본보기가 겹친다: ${rule}`);
+      if (defaults.has(rule)) throw new Error(`프로젝트 기본 예시가 겹친다: ${rule}`);
       defaults.add(rule);
     } else {
       const used = contexts.get(rule) ?? new Set();
       const overlap = presets.filter((preset) => used.has(preset)).sort();
-      if (overlap.length) throw new Error(`프로젝트 본보기의 프리셋이 겹친다: ${rule} ${overlap.join(", ")}`);
+      if (overlap.length) throw new Error(`프로젝트 예시의 프리셋이 겹친다: ${rule} ${overlap.join(", ")}`);
       for (const preset of presets) used.add(preset);
       contexts.set(rule, used);
     }
@@ -166,7 +166,7 @@ export function exemplarFor(rule, preset = null, customExemplars = []) {
   return exemplars().get(rule);
 }
 
-/** 전과 후를 제 줄씩. @param {Exemplar} exemplar @returns {[string, string]} */
+/** 전과 후를 한 줄씩. @param {Exemplar} exemplar @returns {[string, string]} */
 export function twoLines(exemplar) {
   return [shorten(exemplar.before), shorten(exemplar.after)];
 }

package/src/data/load.js

@@ -1,6 +1,6 @@
 // @ts-check
 /**
- * data 폴더를 읽는다. 파이썬 정본의 투영이라 파일 모양이 같다. txt 는 한 줄에 항목 하나, json 은 toml 을 옮긴 것.
+ * data 폴더를 읽는다. 파이썬 자료에서 만든 사본이라 파일 모양이 같다. txt는 한 줄에 항목 하나이고, json은 toml을 옮긴 것이다.
  * 한 번 읽은 것은 기억한다.
  */
 import { compile } from "../regex.js";
@@ -24,7 +24,7 @@ export function readText(name) {
   return readData(name);
 }
 
-/** `#` 으로 시작하면 주석, 빈 줄은 무시. @param {string} name @returns {string[]} */
+/** `#`으로 시작하면 주석, 빈 줄은 무시. @param {string} name @returns {string[]} */
 export function loadLines(name) {
   return cached(`lines:${name}`, () =>
     readText(name)
@@ -39,7 +39,7 @@ export function loadPatterns(name) {
   return cached(`patterns:${name}`, () => loadLines(name).map((line) => compile(line)));
 }
 
-/** toml 의 `[[entry]]` 목록. @param {string} name @returns {Record<string, unknown>[]} */
+/** toml의 `[[entry]]` 목록. @param {string} name @returns {Record<string, unknown>[]} */
 export function loadEntries(name) {
   return cached(`entries:${name}`, () => {
     const data = JSON.parse(readText(name.replace(/\.toml$/, ".json")));
@@ -47,17 +47,17 @@ export function loadEntries(name) {
   });
 }
 
-/** @returns {Record<string, string>} 규칙 이름 → 기술서 (파이썬 docstring 의 투영) */
+/** @returns {Record<string, string>} 규칙 이름 → 설명서(파이썬 docstring에서 만든 사본) */
 export function loadRuleDocs() {
   return cached("ruleDocs", () => JSON.parse(readText("ruleDocs.json")));
 }
 
-/** @returns {Record<string, string>} 규칙 이름 → 부류 (규칙 파일이 사는 폴더의 투영) */
+/** @returns {Record<string, string>} 규칙 이름 → 묶음(규칙 파일이 있는 폴더에서 만든 사본) */
 export function loadRuleCategories() {
   return cached("ruleCategories", () => JSON.parse(readText("ruleCategories.json")));
 }
 
-/** @returns {Record<string, string>} 규칙 이름 → 기제 (파이썬 등록부의 투영) */
+/** @returns {Record<string, string>} 규칙 이름 → 방식(파이썬 규칙 목록에서 만든 사본) */
 export function loadRuleMechanisms() {
   return cached("ruleMechanisms", () => JSON.parse(readText("ruleMechanisms.json")));
 }

package/src/data/operations.js

@@ -1,20 +1,20 @@
 // @ts-check
-/** 승인 고침에서 뜻을 추측하지 않고 재사용할 수 있는 표면 치환. 파이썬 data/operations.py와 같다. */
+/** 승인한 고침에서 뜻을 추측하지 않고 다시 쓸 수 있는 치환. 파이썬 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 이 이미 쓰는 표기로 맞춘다.
+// 파이썬 `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) 을 쓴다.
+// d 플래그로 진짜 그룹 시작을 읽는다. indexOf로 찾으면 [렌더](렌더)처럼 링크 글자와 목적지가 같을 때
+// 링크 글자 쪽을 목적지로 착각한다. 파이썬은 match.start(1)을 쓴다.
 const LINK_DESTINATION_PATTERN = /\[[^\u005D]*\]\(([^)]+)\)/gdu;
 const HTML_TAG_PATTERN = /<[^>\n]+>/gu;
 const DEICTIC_FRAGMENT = /이것|그것|저것|이러한|그러한|해당|이는|그는|그녀|그들/u;
@@ -58,7 +58,7 @@ export function protectedSpans(text) {
     const [start, end] = /** @type {RegExpIndicesArray} */ (match.indices)[1];
     spans.push([start, end]);
   }
-  // 파이썬은 sorted(set(spans)) 라 겹친 구간을 한 번만 둔다 (코드 안의 URL 처럼).
+  // 파이썬은 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]);
 }
@@ -129,7 +129,7 @@ export function surfaceSkeleton(text) {
 }
 
 /**
- * 승인 전후 전체에서 기계가 보증할 수 있는 표면 치환 하나를 추출한다.
+ * 승인 전후 전체에서 기계가 보증할 수 있는 치환 하나를 뽑는다.
  * @param {string} before @param {string} after @param {string[]} [presets] @param {string[]} [protectedTerms]
  * @returns {SurfaceOperation | undefined}
  */
@@ -168,26 +168,26 @@ export function operationFromApproval(before, after, presets = [], protectedTerm
 
 /** @param {unknown} entries @param {string[]} presetNames @returns {SurfaceOperation[]} */
 export function projectOperations(entries, presetNames) {
-  if (!Array.isArray(entries)) throw new Error("operations 는 [[operations]] 배열이다");
+  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}번째 항목은 표다`);
+    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 는 양끝 공백 없는 문자열이다`);
+      throw new Error(`operations ${index}번째 항목의 before는 양끝 공백 없는 문자열이어야 한다`);
     }
     if (typeof after !== "string" || !after.trim() || after !== after.trim()) {
-      throw new Error(`operations ${index}번째 항목의 after 는 양끝 공백 없는 문자열이다`);
+      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 는 비지 않은 문자열 배열이다`);
+      throw new Error(`operations ${index}번째 항목의 presets는 비지 않은 문자열 배열이어야 한다`);
     }
     const presets = /** @type {string[]} */ (rawPresets);
     const unknownPresets = [...new Set(presets.filter((preset) => !knownPresets.has(preset)))].sort();
@@ -195,7 +195,7 @@ export function projectOperations(entries, presetNames) {
     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}`);
+      throw new Error(`operations ${index}번째 항목은 안전한 치환이 아니다: ${before} -> ${after}`);
     }
     for (const preset of presets) {
       const selector = JSON.stringify([preset, before]);

package/src/data/patches.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 글쓴이가 승인한 원문 완전 일치 고침. 파이썬 data/patches.py와 같은 선택 계약이다. */
+/** 글쓴이가 승인한, 원문이 완전히 같을 때만 쓰는 고침. 파이썬 data/patches.py와 같은 조건으로 고른다. */
 import { exemplars, expand } from "./exemplars.js";
 
 export const READER_KINDS = ["recent", "known", "new", "none"];
@@ -13,7 +13,7 @@ export const READER_KINDS = ["recent", "known", "new", "none"];
  * @property {string} cue
  * @property {string} reader
  * @property {string[]} presets
- * @property {string} sentence 마크다운 표식을 걷은 선택용 원문
+ * @property {string} sentence 마크다운 표식을 뺀 선택용 원문
  * @property {string} sourceText 마크다운 표식을 보존한 선택용 원문
  */
 
@@ -22,21 +22,21 @@ export function flatCue(text) {
   return text.split(/\s+/).filter(Boolean).join(" ");
 }
 
-/** 승인 원문은 유니코드 조합과 줄, 연속 공백만 눕혀 비교한다. @param {string} text */
+/** 승인 원문은 유니코드 조합과 줄바꿈, 연속 공백만 정규화해 비교한다. @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]] 배열이다");
+  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}번째 항목은 표다`);
+    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(", ")}`);
@@ -45,7 +45,7 @@ export function projectPatches(entries, presetNames) {
     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} 는 비지 않은 문자열이다`);
+        throw new Error(`patches ${index}번째 항목의 ${key} 값은 비지 않은 문자열이어야 한다`);
       }
       values[key] = value;
     }
@@ -53,11 +53,11 @@ export function projectPatches(entries, presetNames) {
     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}`);
+      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 는 비지 않은 문자열 배열이다`);
+      throw new Error(`patches ${index}번째 항목의 presets는 비지 않은 문자열 배열이어야 한다`);
     }
     const presets = /** @type {string[]} */ (rawPresets);
     const unknownPresets = [...new Set(presets.filter((preset) => !knownPresets.has(preset)))].sort();
@@ -70,12 +70,12 @@ export function projectPatches(entries, presetNames) {
     const after = expand(values.after);
     const rawSentence = entry.sentence ?? before;
     if (typeof rawSentence !== "string" || !rawSentence.trim()) {
-      throw new Error(`patches ${index}번째 항목의 sentence 는 비지 않은 문자열이다`);
+      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 는 비지 않은 문자열이다`);
+      throw new Error(`patches ${index}번째 항목의 sourceText는 비지 않은 문자열이어야 한다`);
     }
     const sourceText = flatSentence(rawSourceText);
     for (const preset of presets) {

package/src/data/patterns.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
- * 문형. 빈칸이 있는 문장 틀. 파이썬 data/patterns.py 와 같다.
- * 본보기가 고친 사례 하나라면 문형은 그 사례를 다시 쓸 수 있는 틀이다.
+ * 문형. 빈칸이 있는 문장 틀. 파이썬 data/patterns.py와 같다.
+ * 예시가 고친 사례 하나라면 문형은 그 사례를 다시 쓸 수 있는 틀이다.
  */
 import { loadEntries } from "./load.js";
 
@@ -9,9 +9,9 @@ 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} when 이 틀을 쓰는 경우
+ * @property {string} example 그 틀로 쓴 문장. hanlint를 통과한다
+ * @property {string} instead 같은 경우에 흔히 쓰는 문장. avoids의 규칙에 잡힌다
  * @property {string[]} avoids
  * @property {string} source
  */

package/src/data/profiles.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
- * 참조 분포 (프로파일) 의 자료형과 읽기. 파이썬 data/profiles.py 와 같다. 종류별 프로파일은 profiles.json (투영) 에서,
- * 사용자 프로파일은 `hanlint profile build` 가 만든 파일에서 읽는다. 히스토그램은 정확한 계수라 두 구현의 셈이 같다.
+ * 참조 분포(프로파일)의 자료형과 읽기. 파이썬 data/profiles.py와 같다. 종류별 프로파일은 profiles.json(파이썬 자료의 사본)에서,
+ * 사용자 프로파일은 `hanlint profile build`가 만든 파일에서 읽는다. 히스토그램은 정확한 계수라 두 구현의 셈이 같다.
  */
 import { readExternal } from "./read.js";
 
@@ -11,7 +11,7 @@ export const PROFILE_VERSION = 1;
 /** 히스토그램의 상한. 이 값보다 큰 것은 상한에 합친다. */
 export const CAP = 200;
 const PERCENTILES = [50, 90, 95, 99];
-/** 기준 말뭉치 종류의 이름. 지적문에 적는다. 파이썬 TYPE_LABELS 와 같다. @type {Record<string, string>} */
+/** 기준 말뭉치 종류의 이름. 지적문에 적는다. 파이썬 TYPE_LABELS와 같다. @type {Record<string, string>} */
 export const TYPE_LABELS = {
   blog: "블로그",
   technicalDocs: "기술 문서",
@@ -87,7 +87,7 @@ function profileFromDict(kind, data) {
 
 /** @type {Map<string, Profile> | null} */
 let shipped = null;
-/** hanlint 가 싣는 종류별 프로파일. @param {string} kind @returns {Profile | null} */
+/** hanlint가 싣는 종류별 프로파일. @param {string} kind @returns {Profile | null} */
 export function profileOf(kind) {
   if (!shipped) {
     shipped = new Map();
@@ -105,7 +105,7 @@ export function userProfile(path) {
   if (!profile) {
     const data = JSON.parse(readExternal(path));
     if (data.version !== PROFILE_VERSION || !("profile" in data)) {
-      throw new Error(`프로파일 파일이 아니다: ${path}. hanlint profile build 로 다시 만든다`);
+      throw new Error(`프로파일 파일이 아니다: ${path}. hanlint profile build로 다시 만든다`);
     }
     profile = profileFromDict("custom", data.profile);
     users.set(path, profile);

package/src/data/prose.js

@@ -1,20 +1,20 @@
 // @ts-check
 /**
- * 쓰기 전에 읽는 작법서. 파이썬 data/prose.py 의 투영이고 정본은 koreanProse.txt 하나다.
- * primer 는 절마다 한 줄로 펴서 첫머리에 싣고, hook --prime 은 본문을 그대로 에이전트 문맥에 넣는다.
+ * 쓰기 전에 읽는 글쓰기 지침. 파이썬 data/prose.py를 옮긴 것이고 내용은 koreanProse.txt 하나에 있다.
+ * primer는 절마다 한 줄로 펴서 첫머리에 싣고, hook --prime은 본문을 그대로 에이전트 문맥에 넣는다.
  */
 import { readText } from "./load.js";
 
 export const PROSE = "koreanProse.txt";
 
-/** 작법서 본문. 끝의 줄바꿈 하나까지 파일 그대로다. @returns {string} */
+/** 글쓰기 지침 본문. 끝의 줄바꿈 하나까지 파일 그대로다. @returns {string} */
 export function proseGuide() {
   return readText(PROSE);
 }
 
 /**
- * (제목, 본문) 짝. 첫 짝은 문서 제목과 첫머리이고 나머지는 일곱 줄이다. 제목의 `#` 는 뗀다.
- * 파이썬 proseSections 와 같다. @returns {[string, string][]}
+ * (제목, 본문) 짝. 첫 짝은 문서 제목과 첫머리이고 나머지는 일곱 줄이다. 제목의 `#`은 뗀다.
+ * 파이썬 proseSections와 같다. @returns {[string, string][]}
  */
 export function proseSections() {
   /** @type {[string, string[]][]} */

package/src/document/model.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
- * 문서 모델. 세 층이다. Block (빈 줄로 나뉜 덩어리), Section (H2 하나가 여는 절), Document (전체).
- * 줄 번호는 1 부터 세고 원문 기준이다.
+ * 문서 모델. 세 단계다. Block (빈 줄로 나뉜 덩어리), Section (H2 하나가 여는 절), Document (전체).
+ * 줄 번호는 1부터 세고 원문 기준이다.
  */
 
 export const PROSE = "prose";
@@ -20,7 +20,7 @@ export const HTML = "html";
  * @property {number} startLine
  * @property {number} endLine
  * @property {string} text
- * @property {number} level heading 일 때 `#` 의 개수
+ * @property {number} level heading 일 때 `#`의 개수
  * @property {number} index 문서 안 순서
  */
 
@@ -37,7 +37,7 @@ export const HTML = "html";
  * @property {Block[]} blocks
  * @property {Section[]} sections
  * @property {[string, number, number][]} disabled 인라인 제어가 끈 (규칙 또는 *, 시작 줄, 끝 줄)
- * @property {Block[]} ignored 설정이 지문에서 뺀 펜스. 파일 전체를 보는 규칙만 읽는다
+ * @property {Block[]} ignored 설정이 글 분석에서 뺀 펜스. 파일 전체를 보는 규칙만 읽는다
  */
 
 /** @param {Section} section */

package/src/document/parseMarkdown.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
- * 마크다운 텍스트를 문서 모델로 바꾼다. 파이썬 document/parseMarkdown.py 와 같은 판정이다.
- * 빈 줄로 블록을 나누고 첫 줄로 종류를 정한다. 코드 펜스 안은 통째로 code 다. H2 가 절을 열고 첫 H2 앞은 도입 절이다.
+ * 마크다운 텍스트를 문서 모델로 바꾼다. 파이썬 document/parseMarkdown.py와 같은 판정이다.
+ * 빈 줄로 블록을 나누고 첫 줄로 종류를 정한다. 코드 펜스 안은 통째로 code다. H2가 절을 열고 첫 H2 앞은 도입 절이다.
  */
 import { splitLines } from "../text.js";
 import { CODE, EMBED, HEADING, HTML, IMAGE, LIST, PROSE, QUOTE, TABLE } from "./model.js";
@@ -16,14 +16,14 @@ const IMAGE_LINE = /^!\[/;
 const LIST_LINE = /^(\s*)(?:[-*+]|\d+[.)])\s+/;
 const TABLE_LINE = /^\s*\|/;
 const URL_LINE = /^\s*https?:\/\/\S+\s*$/;
-// 링크 하나만 있는 줄은 끼워 넣은 것 (영상 카드, 실행 칸, 참고 링크) 이라 주소만 있는 줄과 같은 embed 다. 파이썬과 같다.
+// 링크 하나만 있는 줄은 끼워 넣은 것 (영상 카드, 실행 칸, 참고 링크)이라 주소만 있는 줄과 같은 embed다. 파이썬과 같다.
 const LINK_ONLY_LINE = /^\s*\[[^\]\n]+\]\(\S+?(?:\s+"[^"\n]*")?\)\s*$/;
 const HTML_LINE = /^\s*</;
 const META_KEY = /^[A-Za-z][A-Za-z0-9_]*$/;
 const CONTROL = /^\s*<!--\s*hanlint-(disable-next-line|disable-next|disable|enable)\b([^>]*?)-->\s*$/;
 const ALL_RULES = "*";
 
-/** frontmatter 를 읽고 본문이 시작하는 줄 번호 (1 부터) 를 함께 준다. @param {string} text */
+/** frontmatter를 읽고 본문이 시작하는 줄 번호(1부터)를 함께 준다. @param {string} text */
 export function parseFrontmatter(text) {
   const match = FRONTMATTER.exec(text);
   if (!match) return { meta: {}, firstLine: 1 };
@@ -219,7 +219,7 @@ export function disabledRanges(blocks) {
   return ranges;
 }
 
-/** 코드 블록 첫 줄의 언어 표기 (```python 의 python). 없으면 빈 문자열. 소문자로 준다. @param {string} blockText */
+/** 코드 블록 첫 줄의 언어 표기 (```python의 python). 없으면 빈 문자열. 소문자로 준다. @param {string} blockText */
 export function fenceLanguage(blockText) {
   const opening = FENCE_OPEN.exec(blockText.split("\n", 1)[0]);
   if (!opening) return "";
@@ -228,8 +228,8 @@ export function fenceLanguage(blockText) {
 }
 
 /**
- * 언어 표기가 languages 에 든 펜스를 없앤 문서. 블록 순서 번호를 다시 매기고 절을 다시 묶는다. 인라인 제어는 원문 줄
- * 기준이라 그대로 두고, 뺀 펜스는 ignored 에 남긴다. 파이썬 dropFences 와 같다.
+ * 언어 표기가 languages에 든 펜스를 없앤 문서. 블록 순서 번호를 다시 매기고 절을 다시 묶는다. 인라인 제어는 원문 줄
+ * 기준이라 그대로 두고, 뺀 펜스는 ignored에 남긴다. 파이썬 dropFences와 같다.
  * @param {import("./model.js").Document} doc
  * @param {string[]} languages
  * @returns {import("./model.js").Document}

package/src/document/plainText.js

@@ -1,14 +1,14 @@
 // @ts-check
 /**
  * 산문에서 마크다운 표식을 걷는다. 인라인 코드는 백틱만 떼고 내용은 남긴다. 링크는 보이는 글자만. 강조 표식은 뗀다.
- * 줄바꿈은 남겨 줄 번호 계산에 쓴다. 파이썬 document/plainText.py 와 같다.
- * 인라인 코드가 있던 자리는 codeSpans 로 다시 찾는다. 백틱 안은 사용이 아니라 인용이다.
+ * 줄바꿈은 남겨 줄 번호 계산에 쓴다. 파이썬 document/plainText.py와 같다.
+ * 인라인 코드가 있던 곳은 codeSpans로 다시 찾는다. 백틱 안은 사용이 아니라 인용이다.
  */
 
 const INLINE_CODE = /`([^`\n]*)`/g;
 const LINK = /\[([^\]]*)\]\([^)]*\)/g;
 const EMPHASIS = /(\*\*|__)(?=\S)(.+?)(?<=\S)\1/g;
-// 파이썬의 \w 는 유니코드 글자라 한글을 포함한다. JS 는 \p{L}\p{N}_ 로 같은 뜻을 적는다.
+// 파이썬의 \w는 유니코드 글자라 한글을 포함한다. JS는 \p{L}\p{N}_로 같은 뜻을 적는다.
 const SINGLE_EMPHASIS = /(?<![\p{L}\p{N}_*])\*(?=\S)([^*\n]+?)(?<=\S)\*(?![\p{L}\p{N}_*])/gu;
 const SPACES = /[ \t]+/g;