hanlint 0.0.16 → 0.0.18

package/src/config/settings.js

@@ -66,6 +66,7 @@ PRESETS.chat = [...CONVERSATION, ...SCREEN];
 const SCREEN_OFF = [
   "cliche",
   "connectorRepeat",
+  "phraseRepeat",
   "danglingDeixis",
   "deixis",
   "doubleNegative",
@@ -123,6 +124,11 @@ export const PROFILE_OF = {
   screen: null,
 };
 
+/** 프리셋 → 용례 빈도표의 종류. 정본은 파이썬 config/settings.py 의 USAGE_OF 다. @type {Record<string, string>} */
+export const USAGE_OF = { report: "report" };
+/** 실린 빈도표의 종류. */
+export const USAGE_KINDS = [...new Set(Object.values(USAGE_OF))].sort();
+
 export const PRESET_NAMES = Object.keys(PRESETS);
 /** 설정도 옵션도 없을 때의 종류. 이 이름일 때는 출력에 프리셋을 적지 않는다. */
 export const DEFAULT_PRESET = PRESET_NAMES[0];
@@ -152,6 +158,9 @@ export const DEFAULT_PRESET = PRESET_NAMES[0];
  * @property {number} headingSentenceMaxLevel
  * @property {number} bridgeRepeatMin
  * @property {number} nounPileMin
+ * @property {string | null} usageKind 용례 빈도표의 종류. null 이면 프리셋이 정하고 "" 면 보지 않는다
+ * @property {number} usageMin 명사 연쇄가 몇 편의 문서에 나와야 용례로 보는가
+ * @property {number} usageShare 사전 항목이 그 종류의 문서 몇 할에 나오면 관용으로 보는가
  * @property {number} endingRun
  * @property {number} factListMinSentences
  * @property {number} factListMaxMeanLength
@@ -191,6 +200,9 @@ export function defaultConfig() {
     headingSentenceMaxLevel: 6,
     bridgeRepeatMin: 3,
     nounPileMin: 5,
+    usageKind: null,
+    usageMin: 3,
+    usageShare: 0.9,
     endingRun: 4,
     factListMinSentences: 3,
     factListMaxMeanLength: 8.0,
@@ -235,6 +247,11 @@ export function configFromMapping(data) {
         throw new Error(`enforceStyle 은 ${ENFORCEABLE.join(", ")}의 배열이다`);
       }
       config.enforceStyle = [...value];
+    } else if (key === "usageKind") {
+      if (value !== null && value !== "" && !USAGE_KINDS.includes(/** @type {string} */ (value))) {
+        throw new Error(`usageKind 는 ${USAGE_KINDS.join(", ")} 가운데 하나이거나 빈 문자열이다: ${JSON.stringify(value)}`);
+      }
+      config.usageKind = /** @type {string | null} */ (value);
     } else if (key === "dictionary") {
       config.dictionary = { .../** @type {Record<string, unknown[]>} */ (value) };
     } else if (key === "exemplars") {

package/src/data/profiles.js

@@ -1,7 +1,7 @@
 // @ts-check
 /**
  * 참조 분포 (프로파일) 의 자료형과 읽기. 파이썬 data/profiles.py 와 같다. 종류별 프로파일은 profiles.json (투영) 에서,
- * 사용자 프로파일은 `hanlint profile build` 가 만든 파일에서 읽는다. 히스토그램은 정확한 계수라 두 판의 셈이 같다.
+ * 사용자 프로파일은 `hanlint profile build` 가 만든 파일에서 읽는다. 히스토그램은 정확한 계수라 두 구현의 셈이 같다.
  */
 import { readExternal } from "./read.js";
 
@@ -52,7 +52,7 @@ function histogramFromDict(data) {
   return { total: Number(data.total), counts, percentiles };
 }
 
-/** 값이 이 이상인 것의 몫을 천분율 정수로. 정수 셈이라 두 판의 글자가 같다. @param {Histogram} hist @param {number} value */
+/** 값이 이 이상인 것의 몫을 천분율 정수로. 정수 셈이라 두 구현의 글자가 같다. @param {Histogram} hist @param {number} value */
 export function shareAtOrAbove(hist, value) {
   const capped = Math.min(value, CAP);
   let above = 0;

package/src/data/prose.js

@@ -0,0 +1,27 @@
+// @ts-check
+/**
+ * 쓰기 전에 읽는 작법서. 파이썬 data/prose.py 의 투영이고 정본은 koreanProse.txt 하나다.
+ * primer 는 절마다 한 줄로 펴서 첫머리에 싣고, hook --prime 은 본문을 그대로 에이전트 문맥에 넣는다.
+ */
+import { readText } from "./load.js";
+
+export const PROSE = "koreanProse.txt";
+
+/** 작법서 본문. 끝의 줄바꿈 하나까지 파일 그대로다. @returns {string} */
+export function proseGuide() {
+  return readText(PROSE);
+}
+
+/**
+ * (제목, 본문) 짝. 첫 짝은 문서 제목과 첫머리이고 나머지는 일곱 줄이다. 제목의 `#` 는 뗀다.
+ * 파이썬 proseSections 와 같다. @returns {[string, string][]}
+ */
+export function proseSections() {
+  /** @type {[string, string[]][]} */
+  const sections = [];
+  for (const line of proseGuide().split(/\r?\n/)) {
+    if (line.startsWith("#")) sections.push([line.replace(/^#+/, "").trim(), []]);
+    else if (sections.length) sections[sections.length - 1][1].push(line);
+  }
+  return sections.map(([title, body]) => [title, body.join("\n").trim()]);
+}

package/src/document/sourceText.js

@@ -4,16 +4,29 @@
  * 뜻과 규칙은 파이썬 document/sourceText.py 가 소유한다. 여기는 같은 값을 낸다.
  */
 
-export const SOURCE_SUFFIXES = [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".rs", ".py"];
+export const SOURCE_SUFFIXES = [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".rs", ".py", ".html", ".htm", ".vue", ".svelte"];
+/** 태그 사이 글과 속성값을 JSX 와 같은 길로 읽는 파일. HTML 주석 `<!-- -->` 을 걷어낸다. */
+const MARKUP_SUFFIXES = [".html", ".htm", ".vue", ".svelte"];
 
 const KOREAN = /[가-힣]/;
 // 문자열의 경계. 줄을 앞에서부터 훑어 여는 따옴표에서 같은 닫는 따옴표까지를 한 마디로 본다. 파이썬 sourceText.py 와 같다.
 const QUOTES = ["'", '"', "`"];
-const EXPRESSION = /\{[^{}]*\}/g;
 const BLOCK_COMMENT = /\/\*[\s\S]*?\*\//g;
+const HTML_COMMENT = /<!--[\s\S]*?-->/g;
 const DEVELOPER_LINE = /new Error\(|console\.|panic!\(|expect\(|assert/;
 const RUST_CONTINUATION = /\\\r?\n[ \t]*/g;
 const RUST_TEST_MARKER = "#[cfg(test)]";
+/** 문장을 끊지 않는 HTML 인라인 태그. 같은 줄에서 이 태그만 사이에 둔 글 조각은 한 마디로 잇는다. 파이썬 INLINE_TAGS 와 같다. */
+const INLINE_TAGS = new Set("a abbr b bdi bdo cite code data del dfn em i ins kbd mark q s samp small span strong sub sup time u var wbr br".split(" "));
+const INLINE_TAG = /<\/?([a-zA-Z][a-zA-Z0-9]*)[^<>]*>/g;
+const INLINE_GAP = /^(?:\s*<\/?[a-zA-Z][a-zA-Z0-9]*[^<>]*>)+\s*$/;
+const SIBLING_GAP = /<\/[a-zA-Z][a-zA-Z0-9]*\s*>\s*<[a-zA-Z]/;
+const CODE_OPEN = /<(?:script|style)\b/i;
+const CODE_TAG = /<\/?(?:script|style)\b[^<>]*>/gi;
+const CODE_CLOSE = /<\/(?:script|style)\s*>/i;
+/** 마크업 파일에서 태그도 코드 기호도 없는 줄. 여러 줄 문단의 이어지는 줄이다. */
+const PROSE_LINE = /^(?![\s]*$)[^<>=;{}]*$/;
+const HEAD_TEXT = /^\s*[^<\s][^<]*(?=<\/)/;
 
 /**
  * @typedef {object} SourceLiteral
@@ -23,28 +36,53 @@ const RUST_TEST_MARKER = "#[cfg(test)]";
  * @property {number} column 1부터 세는 칸. 그 줄에서 text 가 시작하는 자리
  */
 
-/** 템플릿 리터럴의 `${ ... }` 식을 (중첩 괄호를 세어) 같은 길이의 빈칸으로 바꾼다. @param {string} source */
-export function withoutTemplateExpressions(source) {
-  let output = "";
+/** `start` 의 `{` 를 닫는 `}` 의 자리. 뜻은 파이썬 balancedEnd 가 소유한다. @param {string} line @param {number} start */
+function balancedEnd(line, start) {
+  let depth = 0;
+  let index = start;
+  while (index < line.length) {
+    const char = line[index];
+    if (QUOTES.includes(char)) {
+      const end = closingQuote(line, index);
+      if (end < 0) return -1;
+      index = end + 1;
+      continue;
+    }
+    if (char === "{") depth += 1;
+    else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+    index += 1;
+  }
+  return -1;
+}
+
+/** 글에 낀 식 `{...}` 와 `${...}` 의 [시작, 끝 다음]. 뜻은 파이썬 expressionSpans 가 소유한다. @param {string} text @returns {[number, number][]} */
+export function expressionSpans(text) {
+  /** @type {[number, number][]} */
+  const spans = [];
   let index = 0;
-  while (index < source.length) {
-    if (source[index] === "$" && source[index + 1] === "{") {
-      let depth = 0;
-      let cursor = index + 1;
-      for (; cursor < source.length; cursor++) {
-        if (source[cursor] === "{") depth += 1;
-        else if (source[cursor] === "}") {
-          depth -= 1;
-          if (depth === 0) break;
-        }
-      }
-      output += " ".repeat(cursor + 1 - index);
-      index = cursor + 1;
+  while (index < text.length) {
+    if (text[index] === "{") {
+      const end = balancedEnd(text, index);
+      if (end < 0) break;
+      const start = index > 0 && text[index - 1] === "$" ? index - 1 : index;
+      spans.push([start, end + 1]);
+      index = end + 1;
       continue;
     }
-    output += source[index];
     index += 1;
   }
+  return spans;
+}
+
+/** 템플릿 리터럴의 `${ ... }` 식을 같은 길이의 빈칸으로 바꾼다. 뜻은 파이썬 withoutTemplateExpressions 가 소유한다. @param {string} source */
+export function withoutTemplateExpressions(source) {
+  let output = source;
+  for (const [start, end] of expressionSpans(source)) {
+    if (source[start] === "$") output = output.slice(0, start) + " ".repeat(end - start) + output.slice(end);
+  }
   return output;
 }
 
@@ -55,25 +93,51 @@ export function userFacingSource(source, path) {
   if (isRust && body.includes(RUST_TEST_MARKER)) body = body.slice(0, body.indexOf(RUST_TEST_MARKER));
   if (isRust) body = body.replace(RUST_CONTINUATION, "");
   body = body.replace(BLOCK_COMMENT, (block) => block.replace(/[^\n]/g, " "));
+  if (MARKUP_SUFFIXES.some((suffix) => path.endsWith(suffix))) body = body.replace(HTML_COMMENT, (block) => block.replace(/[^\n]/g, " "));
   return body
     .split("\n")
     .map((line) => {
       const trimmed = line.trim();
       if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("#")) return "";
       if (DEVELOPER_LINE.test(line)) return "";
-      return line.replace(/\/\/.*$/, "");
+      return withoutLineComment(line);
     })
     .join("\n");
 }
 
+
+/**
+ * 따옴표 밖의 `//` 부터 자른다. `https://` 처럼 `:` 뒤의 `//` 는 주소라 두고, 문자열 안의 `//` 도 둔다.
+ * 뜻은 파이썬 document/sourceText.py 의 withoutLineComment 가 소유한다.
+ */
+export function withoutLineComment(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (quote) {
+      if (char === "\\") { i++; continue; }
+      if (char === quote) quote = null;
+    } else if (char === "'" || char === '"' || char === "`") quote = char;
+    else if (char === "/" && line[i + 1] === "/" && (i === 0 || line[i - 1] !== ":")) return line.slice(0, i);
+  }
+  return line;
+}
+
 /** 검사에 쓰는 글. 식을 비우고 공백을 하나로 모은다. @param {string} text */
 export function plainText(text) {
-  let copy = withoutTemplateExpressions(text);
-  while (EXPRESSION.test(copy)) copy = copy.replace(EXPRESSION, " ");
-  return copy.replace(/\s+/g, " ").trim();
+  let plain = "";
+  let cursor = 0;
+  for (const [start, end] of expressionSpans(text)) {
+    plain += text.slice(cursor, start) + " ";
+    cursor = end;
+  }
+  plain += text.slice(cursor);
+  // 인라인 태그를 비운다. 이름이 영문자로 시작하는 것만이라 `<대상> 필요` 의 꺾쇠는 남는다.
+  plain = plain.replace(INLINE_TAG, (tag, name) => (INLINE_TAGS.has(name.toLowerCase()) ? "" : tag));
+  return plain.replace(/\s+/g, " ").trim();
 }
 
-/** `start` 의 따옴표를 닫는 자리. 역슬래시 뒤 글자는 건너뛴다. 없으면 -1. @param {string} line @param {number} start */
+/** `start` 의 따옴표를 닫는 자리. 백틱 안의 `${...}` 은 통째로 건너뛴다. 뜻은 파이썬 closingQuote 가 소유한다. @param {string} line @param {number} start */
 function closingQuote(line, start) {
   const quote = line[start];
   let index = start + 1;
@@ -83,6 +147,12 @@ function closingQuote(line, start) {
       index += 2;
       continue;
     }
+    if (quote === "`" && char === "$" && line[index + 1] === "{") {
+      const end = balancedEnd(line, index + 1);
+      if (end < 0) return -1;
+      index = end + 1;
+      continue;
+    }
     if (char === quote) return index;
     index += 1;
   }
@@ -96,8 +166,41 @@ function tagCloses(line, index) {
   return "\"'}".includes(before) || /[A-Za-z0-9]/.test(before);
 }
 
-/** 한 줄의 글 마디를 [시작 자리, 글] 로 나온 차례로. 뜻은 파이썬 lineLiterals 가 소유한다. @param {string} line @returns {[number, string][]} */
-export function lineLiterals(line) {
+/** `start` 부터의 JSX 글이 끝나는 `<` 의 자리. 식 안의 `<` 는 글의 끝이 아니다. 뜻은 파이썬 jsxTextEnd 가 소유한다. @param {string} line @param {number} start */
+function jsxTextEnd(line, start) {
+  let index = start;
+  while (index < line.length) {
+    const char = line[index];
+    if (char === "<") return index;
+    if (char === "{") {
+      const end = balancedEnd(line, index);
+      if (end < 0) return -1;
+      index = end + 1;
+      continue;
+    }
+    index += 1;
+  }
+  return -1;
+}
+
+/** 글에 낀 식 안의 글 마디. 뜻은 파이썬 innerLiterals 가 소유한다. @param {string} text @param {number} offset @returns {[number, string][]} */
+function innerLiterals(text, offset) {
+  /** @type {[number, string][]} */
+  const found = [];
+  for (const [start, end] of expressionSpans(text)) {
+    const brace = text[start] === "$" ? start + 1 : start;
+    found.push(...lineLiterals(text.slice(brace + 1, end - 1), offset + brace + 1));
+  }
+  return found;
+}
+
+/** 한 줄의 글 마디를 [시작 자리, 글] 로 나온 차례로. 뜻은 파이썬 lineLiterals 가 소유한다. @param {string} line @param {number} [offset] @returns {[number, string][]} */
+/**
+ * openEnded (마크업 파일) 이면 여는 태그 뒤 줄 끝까지의 글과 줄 처음부터 닫는 태그 앞까지의 글도 마디다.
+ * 뜻은 파이썬 lineLiterals 가 소유한다.
+ * @param {string} line @param {number} [offset] @param {boolean} [openEnded]
+ */
+export function lineLiterals(line, offset = 0, openEnded = false) {
   /** @type {[number, string][]} */
   const found = [];
   let index = 0;
@@ -106,32 +209,92 @@ export function lineLiterals(line) {
     if (QUOTES.includes(char)) {
       const end = closingQuote(line, index);
       if (end < 0) break;
-      found.push([index + 1, line.slice(index + 1, end)]);
+      const raw = line.slice(index + 1, end);
+      found.push([offset + index + 1, raw]);
+      if (char === "`") found.push(...innerLiterals(raw, offset + index + 1));
       index = end + 1;
       continue;
     }
     if (char === ">" && tagCloses(line, index)) {
-      const end = line.indexOf("<", index + 1);
+      let end = jsxTextEnd(line, index + 1);
+      if (end < 0 && openEnded && index + 1 < line.length) end = line.length;
       if (end > index) {
-        const inner = line.slice(index + 1, end);
-        found.push([index + 1, inner]);
-        if (!inner.includes("{")) {
-          index = end;
-          continue;
-        }
+        const raw = line.slice(index + 1, end);
+        found.push([offset + index + 1, raw]);
+        found.push(...innerLiterals(raw, offset + index + 1));
+        index = end;
+        continue;
       }
     }
     index += 1;
   }
-  return found;
+  if (openEnded) {
+    const head = HEAD_TEXT.exec(line);
+    if (head && !found.some(([start]) => start < head[0].length)) found.push([offset, head[0]]);
+    else if (!found.length && PROSE_LINE.test(line)) found.push([offset, line]);
+  }
+  found.sort((a, b) => a[0] - b[0]);
+  return joinInline(line, found, offset);
+}
+
+/**
+ * 사이가 인라인 태그뿐인 태그 사이 글 조각을 한 마디로 잇는다. 태그 안의 속성 문자열은 잇기에 끼지 않고 제 마디로 남는다.
+ * 뜻은 파이썬 joinInline 이 소유한다.
+ * @param {string} line @param {[number, string][]} found @param {number} offset @returns {[number, string][]}
+ */
+function joinInline(line, found, offset) {
+  const pieces = found.filter(([, raw]) => raw.trim());
+  const attributes = pieces.filter(([start]) => insideTag(line, start - offset));
+  /** @type {[number, string][]} */
+  const joined = [];
+  for (const piece of pieces) {
+    if (attributes.includes(piece)) continue;
+    const [start, raw] = piece;
+    if (joined.length) {
+      const [previousStart, previousRaw] = joined[joined.length - 1];
+      const tail = previousStart - offset + previousRaw.length;
+      if (start - offset >= tail && inlineOnly(line.slice(tail, start - offset))) {
+        joined[joined.length - 1] = [previousStart, line.slice(previousStart - offset, start - offset + raw.length)];
+        continue;
+      }
+    }
+    joined.push([start, raw]);
+  }
+  return [...joined, ...attributes].sort((a, b) => a[0] - b[0]);
+}
+
+/** position 이 태그 안 (`<` 뒤, `>` 앞) 인가. @param {string} line @param {number} position */
+function insideTag(line, position) {
+  const opened = line.lastIndexOf("<", position - 1);
+  return opened >= 0 && line.lastIndexOf(">", position - 1) < opened;
+}
+
+/** 사이가 인라인 태그뿐이고 형제 (`</a><a>`) 가 아니다. @param {string} gap */
+function inlineOnly(gap) {
+  if (!INLINE_GAP.test(gap) || SIBLING_GAP.test(gap)) return false;
+  return [...gap.matchAll(INLINE_TAG)].every((match) => INLINE_TAGS.has(match[1].toLowerCase()));
 }
 
 /** 소스에서 글 마디를 줄 번호 순으로. @param {string} source @param {string} [path] @returns {SourceLiteral[]} */
 export function sourceLiterals(source, path = "") {
   /** @type {SourceLiteral[]} */
   const found = [];
+  const markup = MARKUP_SUFFIXES.some((suffix) => path.endsWith(suffix));
+  // 마크업은 주석 지우기가 줄 수를 지키므로 원문 줄과 나란히 간다. script 블록 판정은 원문 줄로 한다 (`// 주석</script>` 가 지워져도).
+  const rawLines = markup ? source.split("\n") : [];
+  let inCode = false;
   userFacingSource(source, path).split("\n").forEach((line, index) => {
-    for (const [start, raw] of lineLiterals(line)) {
+    // <script> 와 <style> 안은 코드다. 열린 조각 규칙을 끄고 따옴표 문자열만 잡는다. 태그 자체는 빈칸으로 바꿔 자리를 지킨다.
+    const rawLine = markup && index < rawLines.length ? rawLines[index] : line;
+    const opensCode = markup && CODE_OPEN.test(rawLine);
+    const closesCode = markup && CODE_CLOSE.test(rawLine);
+    const openEnded = markup && !inCode && !opensCode;
+    if (markup) {
+      if (opensCode && !closesCode) inCode = true;
+      else if (inCode && closesCode) inCode = false;
+    }
+    const scanned = opensCode || closesCode ? line.replace(CODE_TAG, (tag) => " ".repeat(tag.length)) : line;
+    for (const [start, raw] of lineLiterals(scanned, 0, openEnded)) {
       const text = raw.trim();
       const plain = plainText(text);
       if (text && KOREAN.test(plain)) found.push({ line: index + 1, text, plain, column: start + (raw.length - raw.trimStart().length) + 1 });

package/src/fingerprint/build.js

@@ -130,11 +130,15 @@ function quotedIn(sentence, blockSpans) {
 function makeSentencePrint(build, text, line, block, sectionIndex, quoted) {
   const { entries } = build;
   const ending = markers.endingOf(text);
+  const protectedSpans = markers.termSpans(text, build.protectedTerms);
+  // 인용 안의 것과 보호한 용어에 걸친 것은 뺀다. 뜻은 파이썬 fingerprint/build.py 의 kept 가 정한다.
+  /** @param {number} start @param {number} end */
+  const kept = (start, end) => !markers.insideAny(start, end, quoted) && !markers.overlapsAny(start, end, protectedSpans);
   const deixis = markers
     .matchedSpans(text, "deixis.txt")
-    .filter(([start, end]) => !markers.insideAny(start, end, quoted))
+    .filter(([start, end]) => kept(start, end))
     .map(([, , found]) => found);
-  const matches = matchesIn(text, entries).filter((m) => !markers.insideAny(m.start, m.end, quoted));
+  const matches = matchesIn(text, entries).filter((m) => kept(m.start, m.end));
   const mood = markers.moodOf(text, ending);
   return {
     index: build.sentences.length,
@@ -154,7 +158,7 @@ function makeSentencePrint(build, text, line, block, sectionIndex, quoted) {
     euiCount: euiCount(text),
     nounRun: longestNounRun(text),
     passives: doublePassiveSpans(text)
-      .filter(([start, end]) => !markers.insideAny(start, end, quoted))
+      .filter(([start, end]) => kept(start, end))
       .map(([, , surface]) => surface),
     hedges: markers.countMatches(text, "hedges.txt"),
     numbers: markers.countNumbers(text),
@@ -267,7 +271,12 @@ function buildSection(build, section, sectionIndex) {
 export function buildFingerprint(doc, config = defaultConfig()) {
   // 코드도 산문도 아닌 펜스는 지문에 들어오기 전에 뺀다. 모든 진입점이 여기를 지나므로 한 자리면 된다.
   doc = dropFences(doc, config.ignoreFences);
-  const build = { entries: entriesFor(config), sentences: /** @type {SentencePrint[]} */ ([]), paragraphs: /** @type {ParagraphPrint[]} */ ([]) };
+  const build = {
+    entries: entriesFor(config),
+    protectedTerms: config.protectedTerms ?? [],
+    sentences: /** @type {SentencePrint[]} */ ([]),
+    paragraphs: /** @type {ParagraphPrint[]} */ ([]),
+  };
   const { sentences, paragraphs } = build;
   const sections = doc.sections.map((section, index) =>
     buildSection(build, section, index),

package/src/fingerprint/dictionaries.js

@@ -1,5 +1,5 @@
 // @ts-check
-/** 사전 넷을 한 번 컴파일하고 문장에서 맞는 자리를 찾는다. 설정의 dictionary 항목을 더한다. */
+/** 사전들을 한 번 컴파일하고 문장에서 맞는 자리를 찾는다. 설정의 dictionary 항목을 더한다. */
 import { loadEntries } from "../data/load.js";
 import { compile } from "../regex.js";
 
@@ -16,6 +16,7 @@ export const DICTIONARY_FILES = {
   screenNarration: "screenNarration.toml",
   screenTone: "screenTone.toml",
   screenWord: "screenWord.toml",
+  calqueFrame: "calqueFrame.toml",
 };
 const GROUP_REF = /\$(\d)/g;
 const FINALS = { ㄴ: 4, ㄹ: 8 };
@@ -44,6 +45,9 @@ export function expandClasses(pattern) {
  * @property {string} why
  * @property {string} source
  * @property {string | null} fix
+ * @property {{ pattern: import("../regex.js").Pattern, into: string }[]} to 문장 전체를 다시 쓰는 규칙. 앞의 것부터 시도한다
+ * @property {string} raw pattern 의 원문. 내장 항목만 갖고 설정 항목은 빈 글자라 관용으로 접히지 않는다
+ * @property {import("../regex.js").Pattern | null} unless 문장 전체에서 이것이 맞으면 그 문장에서는 항목이 맞지 않는다. 파이썬 Entry.unless 와 같다
  */
 
 /**
@@ -55,10 +59,12 @@ export function expandClasses(pattern) {
  * @property {string} why
  * @property {string} source
  * @property {string | null} fix
+ * @property {string | null} rewrite 항목의 to 규칙으로 문장 전체를 다시 쓴 제안. 없거나 안 맞으면 null
+ * @property {string} pattern 맞은 항목의 pattern 원문. 용례 빈도표의 키다
  */
 
-/** @param {string} dictionary @param {Record<string, unknown> | string} raw @returns {Entry} */
-export function entryFrom(dictionary, raw) {
+/** @param {string} dictionary @param {Record<string, unknown> | string} raw @param {boolean} [builtin] @returns {Entry} */
+export function entryFrom(dictionary, raw, builtin = false) {
   const data = typeof raw === "string" ? { pattern: raw } : raw;
   return {
     dictionary,
@@ -66,6 +72,9 @@ export function entryFrom(dictionary, raw) {
     why: /** @type {string} */ (data.why ?? "설정에서 더한 항목"),
     source: /** @type {string} */ (data.source ?? "설정"),
     fix: /** @type {string | null} */ (data.fix ?? null),
+    to: (/** @type {[string, string][]} */ (data.to ?? [])).map(([source, into]) => ({ pattern: compile(expandClasses(source)), into })),
+    raw: builtin ? /** @type {string} */ (data.pattern) : "",
+    unless: data.unless ? compile(expandClasses(/** @type {string} */ (data.unless))) : null,
   };
 }
 
@@ -75,7 +84,7 @@ export function builtinEntries() {
   if (!builtinCache) {
     builtinCache = [];
     for (const [dictionary, name] of Object.entries(DICTIONARY_FILES)) {
-      for (const raw of loadEntries(name)) builtinCache.push(entryFrom(dictionary, raw));
+      for (const raw of loadEntries(name)) builtinCache.push(entryFrom(dictionary, raw, true));
     }
   }
   return builtinCache;
@@ -99,11 +108,27 @@ export function applyFix(match, fix) {
   return fix.replace(GROUP_REF, (_, n) => match[Number(n)] ?? "");
 }
 
+/**
+ * to 규칙으로 문장을 다시 쓴다. 빈 그룹이 남긴 겹 공백은 하나로 줄이고 양끝을 다듬는다. 원문과 같으면 null.
+ * 뜻은 파이썬 fingerprint/dictionaries.py 의 rewriteBy 가 소유한다.
+ * @param {string} text @param {Entry["to"]} rules
+ */
+export function rewriteBy(text, rules) {
+  for (const { pattern, into } of rules) {
+    const match = pattern.search(text);
+    if (!match) continue;
+    const rewritten = applyFix(match, into).split(/\s+/).filter(Boolean).join(" ");
+    return rewritten && rewritten !== text ? rewritten : null;
+  }
+  return null;
+}
+
 /** @param {string} text @param {Entry[]} entries @returns {DictionaryMatch[]} */
 export function matchesIn(text, entries) {
   /** @type {DictionaryMatch[]} */
   const found = [];
   for (const entry of entries) {
+    if (entry.unless && entry.unless.search(text)) continue;
     for (const match of entry.pattern.all(text)) {
       const start = /** @type {number} */ (match.index);
       found.push({
@@ -114,6 +139,8 @@ export function matchesIn(text, entries) {
         why: entry.why,
         source: entry.source,
         fix: entry.fix ? applyFix(match, entry.fix) : null,
+        rewrite: entry.to.length ? rewriteBy(text, entry.to) : null,
+        pattern: entry.raw,
       });
     }
   }

package/src/fingerprint/markers.js

@@ -147,6 +147,28 @@ export function quoteSpans(text) {
   return found.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
 }
 
+/**
+ * 설정의 protectedTerms 가 글에 나온 [시작, 끝] 전부. 겹쳐 나온 자리도 따로 센다. 파이썬 termSpans 와 같다.
+ * @param {string} text @param {string[]} terms @returns {[number, number][]}
+ */
+export function termSpans(text, terms) {
+  /** @type {[number, number][]} */
+  const found = [];
+  for (const term of terms) {
+    let start = text.indexOf(term);
+    while (start !== -1) {
+      found.push([start, start + term.length]);
+      start = text.indexOf(term, start + 1);
+    }
+  }
+  return found.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+}
+
+/** 두 구간이 한 글자라도 겹치는가. 파이썬 overlapsAny 와 같다. @param {number} start @param {number} end @param {[number, number][]} spans */
+export function overlapsAny(start, end, spans) {
+  return spans.some(([spanStart, spanEnd]) => spanStart < end && start < spanEnd);
+}
+
 /** @param {number} start @param {number} end @param {[number, number][]} spans */
 export function insideAny(start, end, spans) {
   return spans.some(([spanStart, spanEnd]) => spanStart <= start && end <= spanEnd);

package/src/index.js

@@ -26,7 +26,7 @@ import { configFromMapping, defaultConfig } from "./config/settings.js";
 import { loadVersion } from "./data/load.js";
 import { parseMarkdown } from "./document/parseMarkdown.js";
 import { SOURCE_SUFFIXES, replaceLiteral, sourceLiterals } from "./document/sourceText.js";
-import { parseSheet, renderSheet, renderSheetJson } from "./report/sheet.js";
+import { applyRows, parseSheet, renderSheet, renderSheetJson, sheetRows } from "./report/sheet.js";
 import { headingsOf } from "./document/model.js";
 import { applyFixes } from "./edit/applyFixes.js";
 import { buildFingerprint } from "./fingerprint/build.js";
@@ -54,6 +54,8 @@ export {
   parseSheet,
   renderSheet,
   renderSheetJson,
+  sheetRows,
+  applyRows,
   replaceLiteral,
   sourceLiterals,
   CONTRACT_VERSION,

package/src/report/compactReport.js

@@ -1,7 +1,7 @@
 // @ts-check
-/** 한 줄에 지적 하나. AI 와 스크립트가 읽는 꼴이다. 파이썬 report/compactReport.py 와 같은 글자다. */
+/** 한 줄에 지적 하나. AI 와 스크립트가 읽는 형식이다. 파이썬 report/compactReport.py 와 같은 글자다. */
 
-/** 줄바꿈과 이어진 공백을 하나로 눕힌다. 한 줄은 이 꼴의 계약이다. @param {string} text */
+/** 줄바꿈과 이어진 공백을 하나로 눕힌다. 한 줄은 이 형식의 계약이다. @param {string} text */
 function flat(text) {
   return text.split(/\s+/).filter(Boolean).join(" ");
 }
@@ -9,6 +9,10 @@ function flat(text) {
 /** @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
 export function renderCompact(path, findings) {
   return findings
-    .map((f) => `${path}:${f.line} [${f.rule}] ${f.severity === "notice" ? "notice: " : ""}${flat(f.why)}` + (f.fix ? `  고친 뒤: ${flat(f.fix)}` : ""))
+    .map((f) => {
+      const label = f.severity === "notice" ? "notice: " : "";
+      const fixLabel = f.severity === "notice" ? "검토할 대안" : "고친 뒤";
+      return `${path}:${f.line} [${f.rule}] ${label}${flat(f.why)}` + (f.fix ? `  ${fixLabel}: ${flat(f.fix)}` : "");
+    })
     .join("\n");
 }

package/src/report/jsonReport.js

@@ -1,8 +1,8 @@
 // @ts-check
 /**
- * 기계가 읽는 꼴. 평가 루프의 0층 입력이다. 파이썬 json.dumps(indent=2, ensure_ascii=False) 와 같은 글자다.
+ * 기계가 읽는 형식. 평가 루프의 0층 입력이다. 파이썬 json.dumps(indent=2, ensure_ascii=False) 와 같은 글자다.
  * 지적마다 `exemplar` 를 붙인다. 승인 원문 완전 일치 `patch`는 맞는 지적에만 별도로 붙인다.
- * 실제 수정 차이는 파이썬의 exemplarLift와 patchMemory 탐침에서 따로 잰다.
+ * 실제 수정 차이는 파이썬의 exemplarLift와 patchMemory 실험 스크립트에서 따로 잰다.
  */
 import { exemplarFor } from "../data/exemplars.js";
 import { findingAsDict } from "../rules/finding.js";