hanlint 0.0.18 → 0.0.19

package/src/rules/finding.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 지적 하나의 모양. 파이썬 rules/finding.py 와 같은 필드와 같은 JSON 순서다. */
+/** 지적 하나의 형식. 파이썬 rules/finding.py와 필드도 JSON 순서도 같다. */
 
 export const ERROR = "error";
 export const NOTICE = "notice";
@@ -18,10 +18,10 @@ const MIN_LOCAL_CUE = 2;
  * @property {string} quote
  * @property {string} why
  * @property {string | null} fix 기계가 낼 수 있을 때만
- * @property {string} severity error 는 규칙 위반, notice 는 확인이 필요한 것
+ * @property {string} severity error는 규칙 위반, notice는 확인이 필요한 것
  * @property {string} scope sentence, paragraph, section, document
- * @property {number} at scope 가 가리키는 지문의 index
- * @property {string | null} fragment 원문에서 바꿀 조각. hanlint fix 가 replacement 로 바꾼다
+ * @property {number} at scope가 가리키는 분석 결과의 index
+ * @property {string | null} fragment 원문에서 바꿀 조각. hanlint fix가 replacement로 바꾼다
  * @property {string | null} replacement
  * @property {Candidate[]} candidates 뜻을 정하지 않고 형태로 좁힐 수 있을 때만. 순위와 점수는 없다
  */

package/src/rules/paragraph/factListParagraph.js

@@ -20,7 +20,7 @@ export function run(doc, config) {
     if (paragraph.sentenceCount < config.factListMinSentences || isLinked(paragraph)) continue;
     if (paragraph.meanLength <= config.factListMaxMeanLength) {
       findings.push(
-        finding(name, paragraph.startLine, paragraph.sentences[0].text, `문장 ${paragraph.sentenceCount}개에 인과 표지가 하나도 없다. 사실만 나열한 문단일 수 있다. 그래서, 때문에 로 잇는다`, null, NOTICE, PARAGRAPH, paragraph.index),
+        finding(name, paragraph.startLine, paragraph.sentences[0].text, `문장 ${paragraph.sentenceCount}개에 인과 접속사가 하나도 없다. 사실만 나열한 문단일 수 있다. \`그래서\`, \`때문에\`로 잇는다`, null, NOTICE, PARAGRAPH, paragraph.index),
       );
     }
   }

package/src/rules/paragraph/paraFragment.js

@@ -31,7 +31,7 @@ export function run(doc, config) {
     for (const [start] of runsOf(keys, config.fragmentRun)) {
       const first = paragraphs[start];
       findings.push(
-        finding(name, first.startLine, first.sentences.length ? first.sentences[0].text : "", `${config.fragmentRun}개 문단이 연달아 한두 문장씩이다. 화제가 같으면 한 문단으로 묶는다. 줄바꿈은 화제가 바뀌는 자리에만`, null, "error", PARAGRAPH, first.index),
+        finding(name, first.startLine, first.sentences.length ? first.sentences[0].text : "", `${config.fragmentRun}개 문단이 연달아 한두 문장씩이다. 화제가 같으면 한 문단으로 묶는다. 줄바꿈은 화제가 바뀌는 곳에만 둔다`, null, "error", PARAGRAPH, first.index),
       );
     }
   }

package/src/rules/readerDebt.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 독자 부채는 새 판정이 아니라 reader 기제 Finding을 사람이 읽는 이름으로 묶은 것이다. */
+/** 독자가 막힐 곳. 새로 판정하지 않고, reader 방법을 쓰는 규칙의 지적을 사람이 읽을 이름으로 묶는다. */
 
 import { ruleMechanism } from "./registry.js";
 

package/src/rules/registry.js

@@ -1,8 +1,8 @@
 // @ts-check
 /**
- * 규칙 등록부. 규칙 하나는 파일 하나이고 `name` 과 `run(doc, config)` 을 내보낸다. 파이썬은 폴더를 걸어 찾고
- * 여기는 목록으로 든다. test/rules.test.js 가 목록과 폴더와 ruleDocs.json 이 같은지 본다.
- * 기술서 (왜, 어디서, 고치기, 안 잡는 것) 는 파이썬 docstring 의 투영 data/ruleDocs.json 에서 읽는다.
+ * 규칙 목록. 규칙 하나는 파일 하나이고 `name`과 `run(doc, config)`을 내보낸다. 파이썬은 폴더를 걸어 찾고
+ * 여기는 목록으로 든다. test/rules.test.js가 목록과 폴더와 ruleDocs.json이 같은지 본다.
+ * 규칙 설명(왜, 어디서, 고치기, 안 잡는 것)은 파이썬 docstring을 옮긴 data/ruleDocs.json에서 읽는다.
  */
 import { enabled } from "../config/settings.js";
 import { loadRuleCategories, loadRuleDocs } from "../data/load.js";
@@ -66,7 +66,7 @@ import * as screenWord from "./screen/screenWord.js";
 /**
  * @typedef {object} Rule
  * @property {string} name
- * @property {string} mechanism 세는 방법. MECHANISMS 의 키 하나
+ * @property {string} mechanism 세는 방법. MECHANISMS의 키 하나
  * @property {(doc: import("../fingerprint/build.js").DocumentPrint, config: import("../config/settings.js").Config) => import("./finding.js").Finding[]} run
  */
 
@@ -131,19 +131,19 @@ export const RULES = [
 ];
 
 /**
- * 규칙이 세는 방법의 닫힌 집합. 파이썬 rules/registry.py 의 MECHANISMS 와 같은 값과 같은 순서다.
+ * 규칙이 방식의 닫힌 목록. 파이썬 rules/registry.py의 MECHANISMS와 같은 값과 같은 순서다.
  * @type {Record<string, string>}
  */
 export const MECHANISMS = {
-  dictionary: "사전. 낱말 목록과 정규식이 맞는 자리",
-  repeat: "반복. 같은 모양이 창 안에서 N 번",
-  threshold: "셈. 분석표의 값이 임계를 넘거나 모양이 계약과 다른 자리",
-  contrast: "대조. 두 자리를 맞대 어긋난 곳",
-  reader: "독자 상태. 문장 순서대로 독자가 손에 든 것과 본 것에 그 자리가 요구하는 것을 맞댄다",
+  dictionary: "사전. 단어 목록과 정규식이 맞는 곳",
+  repeat: "반복. 같은 모양이 가까이에서 여러 번 나오는 곳",
+  threshold: "수치. 글에서 잰 값이 기준값을 넘거나 정해 둔 형식과 다른 곳",
+  contrast: "비교. 두 곳을 비교해 어긋난 곳",
+  reader: "독자. 앞에서 읽은 내용만으로 그 문장을 이해할 수 있는지 문장 순서대로 본다",
 };
 for (const rule of RULES) {
   if (!(rule.mechanism in MECHANISMS)) {
-    throw new Error(`규칙 ${rule.name} 의 기제 ${rule.mechanism} 은 닫힌 집합 밖이다 (${Object.keys(MECHANISMS).join(", ")}). 새 기제는 규칙 하나 때문에 들어오지 않는다. 멈춰서 묻는다`);
+    throw new Error(`규칙 ${rule.name}의 방식이 닫힌 집합 밖이다: ${rule.mechanism} (있는 것: ${Object.keys(MECHANISMS).join(", ")}). 새 방법은 규칙 하나 때문에 더하지 않는다. 멈추고 묻는다`);
   }
 }
 
@@ -157,7 +157,7 @@ export function ruleNames() {
 /** @param {string} name */
 export function ruleDoc(name) {
   const docs = loadRuleDocs();
-  if (!(name in docs) || !BY_NAME.has(name)) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  if (!(name in docs) || !BY_NAME.has(name)) throw new Error(`모르는 규칙: ${name}. hanlint rules로 목록을 본다`);
   return docs[name];
 }
 
@@ -166,10 +166,10 @@ export function ruleSummary(name) {
   return ruleDoc(name).split("\n")[0];
 }
 
-/** 기술서의 네 절 표. 파이썬 rules/registry.py 의 REQUIRED_SECTIONS 와 같다. */
+/** 기술서의 네 절 표. 파이썬 rules/registry.py의 REQUIRED_SECTIONS와 같다. */
 export const REQUIRED_SECTIONS = ["왜:", "어디서:", "고치기:", "안 잡는 것:"];
 
-/** 기술서에서 절 하나의 본문을 한 줄로. 파이썬 docSection 과 같다. @param {string} doc @param {string} label */
+/** 기술서에서 절 하나의 본문을 한 줄로. 파이썬 docSection과 같다. @param {string} doc @param {string} label */
 export function docSection(doc, label) {
   const collected = [];
   let inside = false;
@@ -188,41 +188,41 @@ export function docSection(doc, label) {
   return collected.filter(Boolean).join(" ");
 }
 
-/** 규칙의 고치기 절 한 줄. primer 가 쓰기 전에 읽히는 그 문장이다. @param {string} name */
+/** 규칙의 고치기 절 한 줄. primer가 쓰기 전에 읽히는 그 문장이다. @param {string} name */
 export function ruleFix(name) {
   return docSection(ruleDoc(name), "고치기:");
 }
 
 /**
- * 부류의 사람 이름. 파이썬 rules/registry.py 의 CATEGORY_TITLES 와 같은 값과 같은 순서다.
+ * 묶음의 사람 이름. 파이썬 rules/registry.py의 CATEGORY_TITLES와 같은 값과 같은 순서다.
  * @type {Record<string, string>}
  */
 export const CATEGORY_TITLES = {
-  sentence: "문장 안에서 세는 것",
-  paragraph: "문단 사이에서 세는 것",
-  structure: "글의 짜임에서 세는 것",
-  document: "두 자리를 대조해 세는 것",
+  sentence: "문장",
+  paragraph: "문단",
+  structure: "글의 짜임",
+  document: "문서",
   orthography: "표기와 띄어쓰기",
-  code: "코드 블록 사이를 대조하는 것",
-  screen: "화면의 글에서 세는 것",
+  code: "코드 블록",
+  screen: "화면의 글",
 };
 
 /** 규칙이 세는 방법. @param {string} name */
 export function ruleMechanism(name) {
   const rule = BY_NAME.get(name);
-  if (!rule) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  if (!rule) throw new Error(`모르는 규칙: ${name}. hanlint rules로 목록을 본다`);
   return rule.mechanism;
 }
 
-/** 규칙이 사는 부류. 정본은 파이썬 쪽 폴더이고 여기는 그 투영을 읽는다. @param {string} name */
+/** 규칙이 사는 묶음. 정본은 파이썬 쪽 폴더이고 여기는 그 투영을 읽는다. @param {string} name */
 export function ruleCategory(name) {
   const categories = loadRuleCategories();
-  if (!(name in categories)) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  if (!(name in categories)) throw new Error(`모르는 규칙: ${name}. hanlint rules로 목록을 본다`);
   return categories[name];
 }
 
 /**
- * 인라인 제어가 그 줄에서 그 규칙을 껐는가. `*` 는 전부다.
+ * 인라인 제어가 그 줄에서 그 규칙을 껐는가. `*`는 전부다.
  * @param {import("./finding.js").Finding} f
  * @param {[string, number, number][]} disabled
  */

package/src/rules/sentence/connectorRepeat.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { SENTENCE, finding } from "../finding.js";
 import { runsOf } from "../shared/repeat.js";
 
@@ -15,7 +16,7 @@ export function run(doc) {
     for (const [start, length, connector] of runsOf(keys, 2)) {
       for (const sentence of sentences.slice(start + 1, start + length)) {
         findings.push(
-          finding(name, sentence.line, sentence.text, `\`${connector}\` 로 시작하는 문장이 연달아 온다. 앞에서 만든 것의 이름을 불러 잇는다`, null, "error", SENTENCE, sentence.index),
+          finding(name, sentence.line, sentence.text, `\`${connector}\`${fitJosa(connector, "로")} 시작하는 문장이 연달아 온다. 앞에서 만든 것의 이름을 불러 잇는다`, null, "error", SENTENCE, sentence.index),
         );
       }
     }

package/src/rules/sentence/danglingDeixis.js

@@ -32,7 +32,7 @@ export function run(doc) {
     if (overlap(reader.recent, sentence.topics) > 0) continue;
     if (isPrompt(reader.previous)) continue;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` ${fitJosa(sentence.deixis[0], "이")} 가리킬 것이 앞 문장에 없다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index, null, null, danglingDeixisCandidates(sentence, reader.previous)),
+      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\`${fitJosa(sentence.deixis[0], "이")} 가리킬 것이 앞 문장에 없다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index, null, null, danglingDeixisCandidates(sentence, reader.previous)),
     );
   }
   return findings;

package/src/rules/sentence/dash.js

@@ -13,7 +13,7 @@ export function run(doc) {
     block.text.split("\n").forEach((lineText, offset) => {
       if (DASHES.test(lineText)) {
         findings.push(
-          finding(name, block.startLine + offset, lineText.trim(), "긴 줄표다. 부연은 마침표로 끊거나 괄호로, 범위는 물결표 ~ 로 쓴다", null, "error", DOCUMENT, block.index),
+          finding(name, block.startLine + offset, lineText.trim(), "긴 줄표다. 덧붙이는 말은 마침표로 끊거나 괄호에 넣고, 범위는 물결표(~)로 쓴다", null, "error", DOCUMENT, block.index),
         );
       }
     });

package/src/rules/sentence/deixis.js

@@ -16,7 +16,7 @@ export function run(doc) {
     const reader = doc.reader.beforeSentence[sentence.index];
     if (overlap(reader.recent, sentence.topics) === 0) continue;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` ${fitJosa(sentence.deixis[0], "은")} 독자가 스크롤을 되돌려야 하는 지시어다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index),
+      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\`${fitJosa(sentence.deixis[0], "은")} 독자가 스크롤을 되돌려야 하는 지시어다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index),
     );
   }
   return findings;

package/src/rules/sentence/doubleNegative.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "doubleNegative";
@@ -24,7 +25,7 @@ export function run(doc) {
     const start = /** @type {number} */ (match.index);
     const fix = replacement ? sentence.text.slice(0, start) + replacement + sentence.text.slice(start + match[0].length) : null;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${match[1]}\` 는 이중 부정이다. 긍정으로 쓴다`, fix, "error", SENTENCE, sentence.index, replacement ? match[1] : null, replacement ?? null),
+      finding(name, sentence.line, sentence.text, `\`${match[1]}\`${fitJosa(match[1], "는")} 이중 부정이다. 긍정으로 쓴다`, fix, "error", SENTENCE, sentence.index, replacement ? match[1] : null, replacement ?? null),
     );
   }
   return findings;

package/src/rules/sentence/doublePassive.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { SENTENCE, finding } from "../finding.js";
 import { doublePassiveCandidates } from "../shared/candidates.js";
 
@@ -38,7 +39,7 @@ export function run(doc) {
           name,
           sentence.line,
           sentence.text,
-          `\`${sentence.passives[0]}\` 는 피동에 어지다 를 또 붙인 이중 피동이다. 하나만 남긴다`,
+          `\`${sentence.passives[0]}\`${fitJosa(sentence.passives[0], "는")} 피동에 \`-어지다\`를 또 붙인 이중 피동이다. 하나만 남긴다`,
           approved ? candidates[0].text : null,
           "error",
           SENTENCE,

package/src/rules/sentence/draftHistory.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { insideAny, matchedSpans } from "../../fingerprint/markers.js";
 import { SENTENCE, finding } from "../finding.js";
 
@@ -16,7 +17,7 @@ export function run(doc, config) {
     for (const [start, end, text] of matchedSpans(sentence.text, "draftHistory.txt")) {
       if (insideAny(start, end, sentence.quoted)) continue;
       findings.push(
-        finding(name, sentence.line, sentence.text, `\`${text}\` 는 글쓴이의 과정이다. 독자는 초고를 본 적이 없다. 알아낸 사실만 결과 문장으로 남긴다`, null, "error", SENTENCE, sentence.index),
+        finding(name, sentence.line, sentence.text, `\`${text}\`${fitJosa(text, "는")} 글쓴이의 과정이다. 독자는 초고를 본 적이 없다. 알아낸 사실만 결과 문장으로 남긴다`, null, "error", SENTENCE, sentence.index),
       );
     }
   }

package/src/rules/sentence/endingRepeat.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { NOTICE, SENTENCE, finding } from "../finding.js";
 import { runsOf } from "../shared/repeat.js";
 
@@ -16,12 +17,12 @@ export function run(doc, config) {
     const sentences = section.paragraphs.flatMap((p) => p.sentences);
     const endings = sentences.map((s) => (COUNTED_ENDINGS.has(s.ending) ? s.ending : `__${s.index}`));
     for (const [start, length, ending] of runsOf(endings, config.endingRun)) {
-      // 구간 어딘가에 이유를 잇는 말이나 독자를 부르는 말이 있으면 리듬이 산 것이다. 구간을 쪼개면
+      // 구간 어딘가에 인과 접속사나 독자에게 말을 거는 문장이 있으면 리듬이 산 것이다. 구간을 쪼개면
       // 조각마다 지적이 되어 오히려 늘어난다. 구간 전체를 하나로 보고 살린다.
       if (sentences.slice(start, start + length).some((s) => s.causal || s.readerCall)) continue;
       const first = sentences[start];
       findings.push(
-        finding(name, first.line, first.text, `\`${ending}\` 로 끝나는 문장 ${length}개에 인과도 질문도 독자를 부르는 말도 없다. 질문, 인과, 행동 동사로 리듬을 바꾼다`, null, NOTICE, SENTENCE, first.index),
+        finding(name, first.line, first.text, `\`${ending}\`${fitJosa(ending, "로")} 끝나는 문장 ${length}개에 인과 접속사도 질문도 독자를 부르는 말도 없다. 질문, 인과 접속사, 행동 동사로 리듬을 바꾼다`, null, NOTICE, SENTENCE, first.index),
       );
     }
   }

package/src/rules/sentence/euiChain.js

@@ -11,7 +11,7 @@ export function run(doc) {
   for (const sentence of doc.sentences) {
     if (sentence.euiCount >= 3 || (sentence.euiCount >= 2 && euiAdjacent(sentence.text))) {
       findings.push(
-        finding(name, sentence.line, sentence.text, `한 문장에 \`의\` 가 ${sentence.euiCount}번이다. 명사를 쌓은 자리라 관계가 표시되지 않는다. 동사로 편다`, null, "error", SENTENCE, sentence.index),
+        finding(name, sentence.line, sentence.text, `한 문장에 \`의\`가 ${sentence.euiCount}번이다. 명사를 쌓은 문장이라 관계가 표시되지 않는다. 동사로 편다`, null, "error", SENTENCE, sentence.index),
       );
     }
   }

package/src/rules/sentence/fillerOpener.js

@@ -12,7 +12,7 @@ export function run(doc) {
     const match = FILLER.exec(sentence.text);
     if (!match) continue;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${match[1]}\` 만 붙여 잇는 문장이다. 앞에서 만든 파일이나 값을 이름으로 다시 부르고 다음 행동을 붙인다`, null, "error", SENTENCE, sentence.index),
+      finding(name, sentence.line, sentence.text, `\`${match[1]}\`만 붙여 잇는 문장이다. 앞에서 만든 파일이나 값을 이름으로 다시 언급하고 다음 행동을 붙인다`, null, "error", SENTENCE, sentence.index),
     );
   }
   return findings;

package/src/rules/sentence/imperativePeriod.js

@@ -14,7 +14,7 @@ export function run(doc) {
     const start = /** @type {number} */ (match.index);
     const fix = sentence.text.slice(0, start) + match[1] + sentence.text.slice(start + match[0].length);
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${match[1]}\` 처럼 명령형과 청유형 뒤에는 마침표를 붙이지 않는다`, fix, "error", SENTENCE, sentence.index, match[0], match[1]),
+      finding(name, sentence.line, sentence.text, `명령·청유 문장 끝(\`${match[1]}\`)에 마침표를 붙이지 않는 표기 방침이다`, fix, "error", SENTENCE, sentence.index, match[0], match[1]),
     );
   }
   return findings;

package/src/rules/sentence/longSentence.js

@@ -14,7 +14,7 @@ export function run(doc, config) {
   for (const sentence of doc.sentences) {
     if (sentence.length > config.longSentenceMax) {
       findings.push(
-        finding(name, sentence.line, sentence.text, `어절 ${sentence.length}개다. 상한은 ${config.longSentenceMax}. 마침표로 끊거나 나열이면 목록으로 꺼낸다`, null, NOTICE, SENTENCE, sentence.index, null, null, longSentenceCandidates(sentence.text)),
+        finding(name, sentence.line, sentence.text, `어절이 ${sentence.length}개로 상한 ${config.longSentenceMax}개를 넘는다. 마침표로 끊거나 나열이면 목록으로 꺼낸다`, null, NOTICE, SENTENCE, sentence.index, null, null, longSentenceCandidates(sentence.text)),
       );
     }
   }

package/src/rules/sentence/negationRedefine.js

@@ -24,7 +24,7 @@ export function run(doc) {
       const current = sentences[i];
       const following = sentences[i + 1];
       if (NEGATION.test(current.text) && isDefinition(following.text)) {
-        findings.push(finding(name, current.line, current.text, "단순한 X 가 아닙니다 뒤에 Y 입니다 로 재정의하는 공식이다. 앞 문장을 지우고 Y 를 바로 쓴다", null, "error", SENTENCE, current.index));
+        findings.push(finding(name, current.line, current.text, "`단순한 X가 아닙니다` 뒤에 `Y입니다`로 다시 정의하는 공식이다. 앞 문장을 지우고 Y를 바로 쓴다", null, "error", SENTENCE, current.index));
       }
     }
   }

package/src/rules/sentence/numberOrphan.js

@@ -37,7 +37,7 @@ export function run(doc, config) {
       if (reader.numerals.has(base) || numeralsIn(sentence.text.slice(0, start)).has(base)) continue;
       if (isAnchored(sentence.text, start)) continue;
       findings.push(
-        finding(name, sentence.line, sentence.text, `\`${base}\` ${fitJosa(base, "가")} 여기서 처음 나오는 값이다. 무엇에서 올라간 것인지 알 수 없다. 그 값이 어디서 나왔는지 밝힌다`, null, NOTICE, SENTENCE, sentence.index),
+        finding(name, sentence.line, sentence.text, `\`${base}\`${fitJosa(base, "가")} 여기서 처음 나오는 값이다. 무엇에서 올라간 것인지 알 수 없다. 그 값이 어디서 나왔는지 밝힌다`, null, NOTICE, SENTENCE, sentence.index),
       );
     }
   }

package/src/rules/sentence/outsideProfile.js

@@ -10,9 +10,14 @@ const FEATURES = [
   ["length", "문장 길이", "어절"],
   ["commas", "쉼표", "개"],
   ["newTopics", "처음 나온 화제어", "개"],
-  ["hedges", "헤지 표현", "개"],
+  ["hedges", "얼버무리는 말", "개"],
 ];
 
+/** 세 자리마다 쉼표를 찍는다. 파이썬 `f"{n:,}"`와 같은 글을 낸다. @param {number} count */
+function grouped(count) {
+  return String(count).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+
 /** @param {import("../../config/settings.js").Config} config */
 function profileFor(config) {
   if (config.profile) return userProfile(config.profile);
@@ -22,7 +27,7 @@ function profileFor(config) {
 
 /** @param {number} permille */
 function shareText(permille) {
-  return permille === 0 ? "0.1% 아래" : `${Math.floor(permille / 10)}.${permille % 10}%`;
+  return permille === 0 ? "0.1% 안" : `${Math.floor(permille / 10)}.${permille % 10}%`;
 }
 
 /** @param {Set<string>} topics @param {Set<string>} known */
@@ -55,7 +60,7 @@ export function run(doc, config) {
           name,
           sentence.line,
           sentence.text,
-          `${label} ${value}${unit}. ${profile.label} ${profile.sentences}문장 가운데 상위 ${shareText(shareAtOrAbove(hist, value))}다. ${p}%는 ${limit}${unit} 이하다`,
+          `${label} ${value}${unit}인 문장이다. ${profile.label} ${grouped(profile.sentences)}문장 가운데 상위 ${shareText(shareAtOrAbove(hist, value))}에 든다. ${p}%는 ${limit}${unit} 이하다`,
           null,
           NOTICE,
           SENTENCE,

package/src/rules/sentence/phraseRepeat.js

@@ -36,12 +36,13 @@ export function run(doc, config) {
     if (hit.length < MIN_HITS || hit.length / prose.length <= share) continue;
     const lines = [...new Set(hit.map((one) => one.line))].sort((a, b) => a - b).join(", ");
     const share100 = `${Math.round(share * 100)}%`;
+    const cited = source ? ` (${source})` : "";
     findings.push(
       finding(
         name,
         hit[0].line,
         hit[0].text,
-        `\`${label}\` 꼴이 산문 ${prose.length}문장 가운데 ${hit.length}번이다 (${lines}줄. 상한 ${share100}). ${why} (${source})`,
+        `\`${label}\` 문형이 산문 ${prose.length}문장 가운데 ${hit.length}번(${lines}줄) 나와 상한 ${share100}를 넘는다. ${why}${cited}`,
         null,
         NOTICE,
         DOCUMENT,

package/src/rules/shared/candidates.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 파이썬 rules/shared/candidates.py의 투영. 후보에는 점수와 순위가 없다. */
+/** 파이썬 rules/shared/candidates.py와 같은 일을 한다. 후보에는 점수와 순위가 없다. */
 import { HAEYO, HANDA, HAPNIDA, REGISTERS, conjugate, fitJosa } from "../../analysis/grammar/index.js";
 import * as hangul from "../../analysis/grammar/hangul.js";
 import { decomposePassive } from "../../analysis/grammar/voice.js";
@@ -123,7 +123,7 @@ export function doublePassiveCandidates(text, passives) {
     const candidateText = reducedPassiveText(text, surface, voice.reduced);
     if (candidateText === null || seen.has(candidateText)) continue;
     seen.add(candidateText);
-    candidates.push({ text: candidateText, why: `\`${surface}\`의 피동 겹을 하나로 줄인다` });
+    candidates.push({ text: candidateText, why: `\`${surface}\`에서 겹친 피동을 하나로 줄인다` });
   }
   return candidates;
 }

package/src/rules/shared/dictionaryRule.js

@@ -18,6 +18,13 @@ function countNewlines(text) {
   return count;
 }
 
+/** 사전 지적의 글. 찾은 말 뒤에 받침에 맞는 은/는을 붙인다. 뜻은 파이썬 rules/shared/dictionaryRule.py 의 message 가 소유한다.
+ * @param {import("../../fingerprint/dictionaries.js").DictionaryMatch} match */
+function message(match) {
+  const source = match.source ? ` (${match.source})` : "";
+  return `\`${match.text}\`${fitJosa(match.text, "는")} ${match.why}${source}`;
+}
+
 /**
  * @param {import("../../fingerprint/build.js").SentencePrint} sentence
  * @param {import("../../fingerprint/dictionaries.js").DictionaryMatch} match
@@ -32,7 +39,7 @@ function matchFinding(sentence, match, ruleName, severity) {
     ruleName,
     sentence.line + countNewlines(sentence.text.slice(0, match.start)),
     sentence.text,
-    `\`${match.text}\` ${match.why} (${match.source})`,
+    message(match),
     fix,
     severity,
     SENTENCE,
@@ -108,7 +115,7 @@ export function firstMatchFindings(doc, dictionary, ruleName, severity = ERROR)
         ruleName,
         sentence.line + countNewlines(sentence.text.slice(0, match.start)),
         sentence.text,
-        `\`${match.text}\` ${match.why} (${match.source})`,
+        message(match),
         match.rewrite,
         severity,
         SENTENCE,

package/src/rules/shared/repeat.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
- * 반복 기제. 같은 모양이 창 안에서 이어지거나 (runsOf) 한 모양이 창을 채우는 (shareOf) 자리를 센다.
- * 파이썬 rules/shared/repeat.py 와 같다. 규칙은 열쇠와 창과 임계만 선언하고 셈은 여기서 한다.
+ * 반복을 세는 방법. 같은 값이 이어지는 구간(runsOf)과 한 값이 차지하는 비율(shareOf)을 센다.
+ * 파이썬 rules/shared/repeat.py와 같다. 규칙은 열쇠와 기준값만 정하고 세는 일은 여기서 한다.
  */
 
 /**

package/src/rules/structure/bridgeRepeat.js

@@ -6,8 +6,8 @@ export const name = "bridgeRepeat";
 export const mechanism = "repeat";
 
 /**
- * 절을 닫는 문장이 이음 표지 (이번에는, 이제, 다음으로) 로 시작하는 절이 bridgeRepeatMin 개 이상인 글.
- * 파이썬 rules/structure/bridgeRepeat.py 와 같다. 표지 목록은 data/bridgeOpeners.txt.
+ * 절을 닫는 문장이 접속사(이번에는, 이제, 다음으로)로 시작하는 절이 bridgeRepeatMin개 이상인 글.
+ * 파이썬 rules/structure/bridgeRepeat.py와 같다. 접속사 목록은 data/bridgeOpeners.txt에 있다.
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc
  * @param {import("../../config/settings.js").Config} config
  */
@@ -30,7 +30,7 @@ export function run(doc, config) {
       name,
       first.line,
       first.text,
-      `절 ${closers.length}개가 \`${markers.join(", ")}\` 같은 이음 표지로 시작하는 문장으로 닫힌다. 예고가 절마다 되풀이되면 틀이다. 방금 만든 결과를 이름으로 부르고 아직 못 하는 일을 적는다`,
+      `절 ${closers.length}개가 \`${markers.join(", ")}\` 같은 접속사로 시작하는 문장으로 끝난다. 예고가 절마다 되풀이되면 틀에 박힌 글이 된다. 방금 만든 결과를 이름으로 부르고 아직 못 하는 일을 적는다`,
       null,
       "error",
       DOCUMENT,

package/src/rules/structure/emojiBullet.js

@@ -26,7 +26,7 @@ export function run(doc) {
     const lines = block.text.split("\n");
     for (let offset = 0; offset < lines.length; offset++) {
       if (BULLET_WITH_EMOJI.test(lines[offset])) {
-        findings.push(finding(name, block.startLine + offset, lines[offset].trim(), "목록 항목이 이모지로 시작한다. 이모지를 지우고 첫 낱말이 내용을 말하게 한다", null, "error", DOCUMENT, block.index));
+        findings.push(finding(name, block.startLine + offset, lines[offset].trim(), "목록 항목이 이모지로 시작한다. 이모지를 지우고 첫 단어가 내용을 말하게 한다", null, "error", DOCUMENT, block.index));
         break;
       }
     }

package/src/rules/structure/headingSkip.js

@@ -11,7 +11,7 @@ export function run(doc) {
   let previous = doc.frontmatter.title ? 1 : null;
   for (const [level, text, line] of doc.headings) {
     if (previous !== null && level > previous + 1) {
-      findings.push(finding(name, line, text, `H${previous} 다음에 H${level} 이 온다. 한 수준씩 내려간다`, null, "error", DOCUMENT, -1));
+      findings.push(finding(name, line, text, `H${previous} 다음에 바로 H${level} 제목이 온다. 한 수준씩 내려간다`, null, "error", DOCUMENT, -1));
     }
     previous = level;
   }

package/src/rules/structure/headingUniform.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { DOCUMENT, finding } from "../finding.js";
 import { shareOf } from "../shared/repeat.js";
 
@@ -27,7 +28,7 @@ export function run(doc, config) {
   );
   if (count / total >= config.headingUniformRatio) {
     return [
-      finding(name, eligible[0][2], eligible.map(([, text]) => text).join(" / "), `H2 ${eligible.length}개 중 ${count}개가 \`${best}\` 로 끝난다. 목차가 한 어미로 끝나면 과정이 아니라 나열로 읽힌다. 그 문서의 관례라면 둔다`, null, "notice", DOCUMENT, -1),
+      finding(name, eligible[0][2], eligible.map(([, text]) => text).join(" / "), `H2 ${eligible.length}개 가운데 ${count}개가 \`${best}\`${fitJosa(best, "로")} 끝난다. 목차가 한 어미로 끝나면 과정이 아니라 나열로 읽힌다. 그 문서의 관례라면 그대로 둔다`, null, "notice", DOCUMENT, -1),
     ];
   }
   return [];

package/src/rules/structure/loneSubheading.js

@@ -5,7 +5,7 @@ import { NOTICE, SECTION, finding } from "../finding.js";
 export const name = "loneSubheading";
 export const mechanism = "contrast";
 
-/** (부모 H2 제목, 외동 H3 제목, 그 줄). H2 하나 아래 H3 이 정확히 하나일 때만. @param {[number, string, number][]} headings */
+/** (부모 H2 제목, 하나뿐인 H3 제목, 그 줄). H2 하나 아래 H3이 정확히 하나일 때만. @param {[number, string, number][]} headings */
 function onlyChild(headings) {
   /** @type {[string, string, number][]} */
   const found = [];

package/src/rules/structure/moreLater.js

@@ -43,6 +43,6 @@ export function run(doc, config) {
   let best = over[0];
   for (const pair of over) if (pair[1].length > best[1].length) best = pair;
   return [
-    finding(name, best[0], best[1], `마지막 절의 목록 항목 ${over.length}개가 ${config.moreLaterMaxChars}자를 넘는다 (가장 긴 것 ${best[1].length}자). 미룬 것이 아니라 옮겨 적은 것이다. 한 줄과 링크로 줄인다`, null, NOTICE, SECTION, last.index),
+    finding(name, best[0], best[1], `마지막 절의 목록 항목 ${over.length}개가 ${config.moreLaterMaxChars}자를 넘는다. 가장 긴 항목은 ${best[1].length}자다. 미룬 것이 아니라 옮겨 적은 것이다. 한 줄과 링크로 줄인다`, null, NOTICE, SECTION, last.index),
   ];
 }

package/src/text.js

@@ -64,8 +64,8 @@ export function countIn(text, needle, end = text.length) {
 
 /**
  * 파이썬 round(value, digits). 정확한 이진 값을 십진으로 풀어 반올림하고 정확히 절반이면 짝수로 간다.
- * Math.round 는 절반을 위로 올려 13/16 을 0.813 으로 만들고 파이썬은 0.812 다. 두 구현의 글자가 같으려면 파이썬 쪽이다.
- * toFixed(100) 은 1e21 아래의 수를 정확한 십진 전개로 준다. 지문의 비율과 평균이 사는 범위다.
+ * Math.round는 절반을 위로 올려 13/16을 0.813으로 만들고 파이썬은 0.812다. 두 구현의 글자가 같으려면 파이썬 쪽이다.
+ * toFixed(100)은 1e21 아래의 수를 정확한 십진 전개로 준다. 분석 결과의 비율과 평균이 있는 범위다.
  * @param {number} value
  * @param {number} digits
  */

package/src/usage/counts.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
  * 명사 연쇄 빈도표. 글 종류마다 data/usageCounts.<종류>.json 하나이고 값은 그 연쇄가 나온 문서 수다.
- * 뜻은 파이썬 usage/counts.py 가 소유한다. 표의 키는 nounRuns 의 어절들을 빈칸 하나로 이은 것이다.
+ * 뜻은 파이썬 usage/counts.py가 정한다. 표의 키는 nounRuns의 어절들을 빈칸 하나로 이은 것이다.
  */
 import { USAGE_OF } from "../config/settings.js";
 import { readText } from "../data/load.js";
@@ -12,7 +12,7 @@ import { readText } from "../data/load.js";
 const tables = new Map();
 
 /**
- * 이 설정이 볼 빈도표의 종류. usageKind 가 null 이면 프리셋이 정하고 "" 면 보지 않는다.
+ * 이 설정이 볼 빈도표의 종류. usageKind가 null이면 프리셋이 정하고 ""면 보지 않는다.
  * @param {import("../config/settings.js").Config} config @returns {string | null}
  */
 export function usageKindOf(config) {
@@ -46,7 +46,7 @@ export function patternDocuments(dictionary, pattern, kind) {
 }
 
 /**
- * 사전 항목이 그 종류의 문서 share 이상에 나오면 관용이다. 뜻은 파이썬 usage/counts.py 의 conventional 이 소유한다.
+ * 사전 항목이 그 종류의 문서 share 이상에 나오면 관용이다. 뜻은 파이썬 usage/counts.py의 conventional이 정한다.
  * @param {string} dictionary @param {string} pattern @param {string} kind @param {number} share
  */
 export function conventional(dictionary, pattern, kind, share) {

package/src/usage/index.js

@@ -1,8 +1,8 @@
 // @ts-check
 /**
- * 용례 (usage). 실제 글에서 낱말이 어떻게 쓰였는지를 든다. 뜻은 파이썬 usage/ 가 소유한다.
- * counts 는 실리는 빈도표, sentences 는 사용자 기계의 문장 역인덱스다.
- * fingerprint 와 같은 층이다. rules 와 cli 가 쓰고, analysis 와 config 와 data 만 쓴다.
+ * 용례(usage). 실제 글에서 단어가 어떻게 쓰였는지를 든다. 뜻은 파이썬 usage/가 정한다.
+ * counts는 실리는 빈도표, sentences는 사용자 기계의 문장 역인덱스다.
+ * fingerprint와 같은 단계다. rules와 cli가 이 부분을 쓰고, 이 부분은 analysis와 config와 data만 쓴다.
  */
 export { attested, chainDocuments, conventional, patternDocuments, usageKindOf, usageTable } from "./counts.js";
 export { UsageIndex, buildIndex, defaultRoot as defaultUsageRoot, indexTokens, listIndexes, loadIndex, queryCores, readDocuments } from "./sentences.js";