hanlint 0.0.7 → 0.0.8

package/src/rules/sentence/deixis.js

@@ -1,18 +1,22 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { overlap } from "../../fingerprint/topics.js";
 import { SENTENCE, finding } from "../finding.js";
+import { hasLocalAntecedent } from "../shared/localAntecedent.js";
 
 export const name = "deixis";
+export const mechanism = "reader";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const sentence of doc.sentences) {
     if (!sentence.deixis.length || sentence.index === 0) continue;
-    const previous = doc.sentences[sentence.index - 1];
-    if (overlap(previous.topics, sentence.topics) === 0) continue;
+    if (hasLocalAntecedent(sentence)) continue;
+    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]}\` 은 독자가 스크롤을 되돌려야 하는 지시어다. 가리키는 파일, 값, 코드의 이름을 쓴다`, 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

@@ -2,13 +2,16 @@
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "doubleNegative";
-const DOUBLE_NEGATIVE = /(하지 않으면 안 (?:된다|됩니다)|하지 않을 수 없(?:다|습니다)|지 않으면 안 (?:된다|됩니다)|지 않을 수 없(?:다|습니다))/;
+export const mechanism = "dictionary";
+const DOUBLE_NEGATIVE = /(하지 않으면 안 (?:된다|됩니다|돼요)|하지 않을 수 없(?:다|습니다|어요)|지 않으면 안 (?:된다|됩니다|돼요)|지 않을 수 없(?:다|습니다|어요))/;
 /** @type {Record<string, string>} */
 const FIXES = {
   "하지 않으면 안 된다": "해야 한다",
   "하지 않으면 안 됩니다": "해야 합니다",
   "하지 않을 수 없다": "한다",
   "하지 않을 수 없습니다": "합니다",
+  "하지 않으면 안 돼요": "해야 해요",
+  "하지 않을 수 없어요": "해요",
 };
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */

package/src/rules/sentence/doublePassive.js

@@ -1,15 +1,52 @@
 // @ts-check
 import { SENTENCE, finding } from "../finding.js";
+import { doublePassiveCandidates } from "../shared/candidates.js";
 
 export const name = "doublePassive";
+export const mechanism = "dictionary";
+
+/** 검토를 통과한 이중 피동 후보에서 인용 밖의 단일 치환만 꺼낸다.
+ * @param {string} text @param {string} candidateText @param {[number, number][]} quoted
+ * @returns {[string, string] | null} */
+function approvedEdit(text, candidateText, quoted) {
+  let prefix = 0;
+  while (prefix < text.length && prefix < candidateText.length && text[prefix] === candidateText[prefix]) prefix += 1;
+  let suffix = 0;
+  while (
+    suffix < text.length - prefix &&
+    suffix < candidateText.length - prefix &&
+    text[text.length - suffix - 1] === candidateText[candidateText.length - suffix - 1]
+  ) suffix += 1;
+  const sourceEnd = text.length - suffix;
+  const candidateEnd = candidateText.length - suffix;
+  const fragment = text.slice(prefix, sourceEnd);
+  const replacement = candidateText.slice(prefix, candidateEnd);
+  if (!fragment || text.indexOf(fragment) !== text.lastIndexOf(fragment)) return null;
+  if (quoted.some(([start, end]) => prefix < end && sourceEnd > start)) return null;
+  return [fragment, replacement];
+}
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const sentence of doc.sentences) {
     if (sentence.passives.length) {
+      const candidates = doublePassiveCandidates(sentence.text, sentence.passives);
+      const approved = candidates.length === 1 ? approvedEdit(sentence.text, candidates[0].text, sentence.quoted) : null;
       findings.push(
-        finding(name, sentence.line, sentence.text, `\`${sentence.passives[0]}\` 는 피동에 어지다 를 또 붙인 이중 피동이다. 하나만 남긴다`, null, "error", SENTENCE, sentence.index),
+        finding(
+          name,
+          sentence.line,
+          sentence.text,
+          `\`${sentence.passives[0]}\` 는 피동에 어지다 를 또 붙인 이중 피동이다. 하나만 남긴다`,
+          approved ? candidates[0].text : null,
+          "error",
+          SENTENCE,
+          sentence.index,
+          approved ? approved[0] : null,
+          approved ? approved[1] : null,
+          approved ? [] : candidates,
+        ),
       );
     }
   }

package/src/rules/sentence/draftHistory.js

@@ -0,0 +1,24 @@
+// @ts-check
+import { insideAny, matchedSpans } from "../../fingerprint/markers.js";
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "draftHistory";
+export const mechanism = "dictionary";
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  void config;
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    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),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/ellipsis.js

@@ -1,16 +1,30 @@
 // @ts-check
+import { insideAny } from "../../fingerprint/markers.js";
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "ellipsis";
-// 괄호 안의 점 셋 (`OVER (...)`) 은 인라인 코드의 생략 표기라 뺀다.
+export const mechanism = "dictionary";
 // 영숫자에 붙은 점 셋 (`v0.0.1...HEAD`, compare URL) 은 범위 표기라 말줄임표가 아니다.
-const ELLIPSIS = /(?<![(\[A-Za-z0-9])(…|\.{3,})(?![)\]A-Za-z0-9])/;
+// 인라인 코드와 따옴표 안은 지문이 인용 구간으로 이미 표시해 두었으므로 여기서 다시 재지 않는다.
+const ELLIPSIS = /(?<![A-Za-z0-9])(…|\.{3,})(?![A-Za-z0-9])/g;
+const CLI_OPTION = /(?:^|\s)--?[A-Za-z0-9]/;
+
+/** 괄호 안 명령 예시의 생략 인자. 예: (kubectl get -o yaml …). @param {string} text @param {number} start @param {number} end */
+function insideCommandExample(text, start, end) {
+  const opened = text.lastIndexOf("(", start);
+  const closed = text.indexOf(")", end);
+  return opened >= 0 && closed >= 0 && !text.slice(opened, start).includes(")") && !text.slice(end, closed).includes("(") && CLI_OPTION.test(text.slice(opened + 1, closed));
+}
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const sentence of doc.sentences) {
-    if (ELLIPSIS.test(sentence.text)) {
+    const found = [...sentence.text.matchAll(ELLIPSIS)].filter((m) => {
+      const start = /** @type {number} */ (m.index);
+      return !insideAny(start, start + m[0].length, sentence.quoted) && !insideCommandExample(sentence.text, start, start + m[0].length);
+    });
+    if (found.length) {
       findings.push(finding(name, sentence.line, sentence.text, "말줄임표로 말끝을 흐리면 독자가 결론을 받아 가지 못한다. 문장을 끝까지 쓴다", null, "error", SENTENCE, sentence.index));
     }
   }

package/src/rules/sentence/endingRepeat.js

@@ -1,8 +1,9 @@
 // @ts-check
 import { NOTICE, SENTENCE, finding } from "../finding.js";
-import { runsOf } from "../shared/runs.js";
+import { runsOf } from "../shared/repeat.js";
 
 export const name = "endingRepeat";
+export const mechanism = "repeat";
 const COUNTED_ENDINGS = new Set(["니다", "다", "것이다", "요", "죠"]);
 
 /**
@@ -15,9 +16,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}\` 로 끝나는 문장 ${length}개에 인과도 질문도 독자를 부르는 말도 없다. 질문, 인과, 행동 동사로 리듬을 바꾼다`, null, NOTICE, SENTENCE, first.index),
       );
     }
   }

package/src/rules/sentence/euiChain.js

@@ -1,14 +1,15 @@
 // @ts-check
+import { euiAdjacent } from "../../analysis/index.js";
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "euiChain";
-const ADJACENT = /[가-힣]+의\s+[가-힣]+의(?=[\s,.)\]]|$)/;
+export const mechanism = "threshold";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const sentence of doc.sentences) {
-    if (sentence.euiCount >= 3 || (sentence.euiCount >= 2 && ADJACENT.test(sentence.text))) {
+    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),
       );

package/src/rules/sentence/fillerOpener.js

@@ -2,6 +2,7 @@
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "fillerOpener";
+export const mechanism = "dictionary";
 const FILLER = /^(다음으로|이어서|마지막에는|마지막으로)(?=[\s,])/;
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */

package/src/rules/sentence/hardWord.js

@@ -3,6 +3,7 @@ import { NOTICE } from "../finding.js";
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "hardWord";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/sentence/imperativePeriod.js

@@ -2,7 +2,8 @@
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "imperativePeriod";
-const IMPERATIVE_PERIOD = /(세요|십시오|합시다|봅시다|하자|해라)\.(?=\s|$)/;
+export const mechanism = "dictionary";
+const IMPERATIVE_PERIOD = /(세요|십시오|합시다|봅시다|하자|해라|라)\.(?=\s|$)/;
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/sentence/japaneseLoan.js

@@ -2,6 +2,7 @@
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "japaneseLoan";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/sentence/longSentence.js

@@ -1,7 +1,9 @@
 // @ts-check
 import { NOTICE, SENTENCE, finding } from "../finding.js";
+import { longSentenceCandidates } from "../shared/candidates.js";
 
 export const name = "longSentence";
+export const mechanism = "threshold";
 
 /**
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc
@@ -12,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),
+        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

@@ -1,10 +1,19 @@
 // @ts-check
 import { SENTENCE, finding } from "../finding.js";
+import { COPULA as COPULA_KIND, lastWord, parsePredicate } from "../../analysis/grammar/index.js";
 
 export const name = "negationRedefine";
+export const mechanism = "repeat";
 const NEGATION = /단순(?:한|히)\s?.{0,15}?(?:이|가)\s?아(?:닙니다|니다|니에요|니죠|닌)/;
 const COPULA = /(입니다|이다|이에요|예요)[.!]?$/;
 
+/** @param {string} text */
+function isDefinition(text) {
+  if (COPULA.test(text.trim())) return true;
+  const predicate = parsePredicate(lastWord(text));
+  return predicate !== null && predicate.kind === COPULA_KIND;
+}
+
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
@@ -13,7 +22,7 @@ export function run(doc) {
     for (let i = 0; i + 1 < sentences.length; i++) {
       const current = sentences[i];
       const following = sentences[i + 1];
-      if (NEGATION.test(current.text) && COPULA.test(following.text.trim())) {
+      if (NEGATION.test(current.text) && isDefinition(following.text)) {
         findings.push(finding(name, current.line, current.text, "단순한 X 가 아닙니다 뒤에 Y 입니다 로 재정의하는 공식이다. 앞 문장을 지우고 Y 를 바로 쓴다", null, "error", SENTENCE, current.index));
       }
     }

package/src/rules/sentence/nounPile.js

@@ -2,6 +2,7 @@
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "nounPile";
+export const mechanism = "threshold";
 
 /**
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc

package/src/rules/sentence/numberOrphan.js

@@ -0,0 +1,45 @@
+// @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
+import { matchedTexts, numeralsIn } from "../../fingerprint/markers.js";
+import { NOTICE, SENTENCE, finding } from "../finding.js";
+
+export const name = "numberOrphan";
+export const mechanism = "reader";
+const RANGE = /(\d[\d,]*(?:\.\d+)?)[^\s.!?]{0,4}\s?에서\s?(\d[\d,]*(?:\.\d+)?)[^\s.!?]{0,4}\s?(?:로|으로)/g;
+/** 한 자리 수는 재는 값이 아니라 세는 말이라 뺀다. */
+const MIN_DIGITS = 2;
+/** 기준값 앞 몇 글자에서 출처를 밝히는 말을 찾는가. */
+const ANCHOR_WINDOW = 12;
+
+/** @param {string} numeral */
+function isMeasured(numeral) {
+  return numeral.includes(".") || numeral.replaceAll(".", "").length >= MIN_DIGITS;
+}
+
+/** 값 바로 앞이 그 값이 어디서 온 것인지 말하고 있는가. @param {string} text @param {number} start */
+function isAnchored(text, start) {
+  return matchedTexts(text.slice(Math.max(0, start - ANCHOR_WINDOW), start), "baselineAnchors.txt").length > 0;
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  void config;
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    const reader = doc.reader.beforeSentence[sentence.index];
+    for (const match of sentence.text.matchAll(RANGE)) {
+      const base = match[1].replaceAll(",", "");
+      if (!isMeasured(base) || base === match[2].replaceAll(",", "")) continue;
+      const start = /** @type {number} */ (match.index);
+      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),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/outsideProfile.js

@@ -0,0 +1,68 @@
+// @ts-check
+import { PROFILE_OF } from "../../config/settings.js";
+import { profileOf, shareAtOrAbove, userProfile } from "../../data/profiles.js";
+import { NOTICE, SENTENCE, finding } from "../finding.js";
+
+export const name = "outsideProfile";
+export const mechanism = "threshold";
+/** 대조하는 문장 지표와 지적문의 이름과 단위. 파이썬 outsideProfile.py 와 같다. */
+const FEATURES = [
+  ["length", "문장 길이", "어절"],
+  ["commas", "쉼표", "개"],
+  ["newTopics", "처음 나온 화제어", "개"],
+  ["hedges", "헤지 표현", "개"],
+];
+
+/** @param {import("../../config/settings.js").Config} config */
+function profileFor(config) {
+  if (config.profile) return userProfile(config.profile);
+  const kind = PROFILE_OF[config.preset];
+  return kind ? profileOf(kind) : null;
+}
+
+/** @param {number} permille */
+function shareText(permille) {
+  return permille === 0 ? "0.1% 아래" : `${Math.floor(permille / 10)}.${permille % 10}%`;
+}
+
+/** @param {Set<string>} topics @param {Set<string>} known */
+function freshCount(topics, known) {
+  let fresh = 0;
+  for (const topic of topics) if (!known.has(topic)) fresh += 1;
+  return fresh;
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const profile = profileFor(config);
+  if (!profile) return [];
+  const p = config.profilePercentile;
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    const known = doc.reader.beforeSentence[sentence.index].known;
+    const values = { length: sentence.length, commas: sentence.commas, newTopics: freshCount(sentence.topics, known), hedges: sentence.hedges };
+    for (const [key, label, unit] of FEATURES) {
+      const hist = profile.sentence.get(key);
+      if (!hist || !hist.percentiles.has(p)) continue;
+      const limit = /** @type {number} */ (hist.percentiles.get(p));
+      const value = values[/** @type {"length" | "commas" | "newTopics" | "hedges"} */ (key)];
+      if (limit === 0 || value <= limit) continue;
+      findings.push(
+        finding(
+          name,
+          sentence.line,
+          sentence.text,
+          `${label} ${value}${unit}. ${profile.label} ${profile.sentences}문장 가운데 상위 ${shareText(shareAtOrAbove(hist, value))}다. ${p}%는 ${limit}${unit} 이하다`,
+          null,
+          NOTICE,
+          SENTENCE,
+          sentence.index,
+        ),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/redundantPair.js

@@ -2,6 +2,7 @@
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "redundantPair";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/sentence/translationese.js

@@ -2,6 +2,7 @@
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "translationese";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/shared/candidates.js

@@ -0,0 +1,129 @@
+// @ts-check
+/** 파이썬 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";
+import { stripJosa, words } from "../../analysis/tokenize.js";
+import { loadLines } from "../../data/load.js";
+
+const ENDING_CANDIDATES = {
+  [HAPNIDA]: [["-습니까?", "같은 문체의 의문형"], ["-기 때문입니다", "같은 문체의 인과형"]],
+  [HANDA]: [["-는가?", "같은 문체의 의문형"], ["-기 때문이다", "같은 문체의 인과형"]],
+  [HAEYO]: [["-나요?", "같은 문체의 의문형"], ["-기 때문이에요", "같은 문체의 인과형"]],
+};
+
+/** @param {string} text @returns {import("../finding.js").Candidate[]} */
+export function longSentenceCandidates(text) {
+  const endings = [...loadLines("candidateSplitEndings.txt")].sort((a, b) => b.length - a.length);
+  const pattern = new RegExp(`([가-힣]+(${endings.join("|")}))[,;]?\\s+`, "g");
+  const candidates = [];
+  for (const match of text.matchAll(pattern)) {
+    const word = match[1];
+    const ending = match[2];
+    if (word === "그리고" || word.length <= ending.length) continue;
+    const end = /** @type {number} */ (match.index) + match[0].length;
+    const marked = text.slice(0, end).trimEnd() + " | " + text.slice(end).trimStart();
+    candidates.push({ text: marked, why: `연결 어미 \`${ending}\` 뒤를 문장 경계로 검토한다` });
+  }
+  return candidates;
+}
+
+/** @param {string} topic @param {string} deixis */
+function replacementForDeixis(topic, deixis) {
+  if (deixis.startsWith("이것")) {
+    const suffix = deixis.slice("이것".length);
+    return topic + fitJosa(topic, suffix);
+  }
+  if (deixis.startsWith("해당 ")) {
+    const last = deixis.trim().split(/\s+/).at(-1) ?? "";
+    const base = stripJosa(last);
+    return topic + fitJosa(topic, last.slice(base.length));
+  }
+  if (deixis.startsWith("이러한 ")) return topic + "의 " + deixis.slice("이러한 ".length);
+  if (deixis === "이처럼") return topic + "처럼";
+  return topic;
+}
+
+/** @param {import("../../fingerprint/build.js").SentencePrint} current @param {import("../../fingerprint/build.js").SentencePrint | null} previous */
+export function danglingDeixisCandidates(current, previous) {
+  if (previous === null || !current.deixis.length) return [];
+  const deixis = current.deixis[0];
+  const topics = [...previous.topics].sort((a, b) => previous.text.toLowerCase().indexOf(a) - previous.text.toLowerCase().indexOf(b) || a.localeCompare(b));
+  return topics.map((topic) => ({
+    text: current.text.replace(deixis, replacementForDeixis(topic, deixis)),
+    why: `바로 앞 문장에 나온 명사 \`${topic}\``,
+  }));
+}
+
+/** @param {string} text */
+export function nounPileCandidates(text) {
+  const actionNouns = new Set(loadLines("candidateActionNouns.txt"));
+  const found = [];
+  for (const word of words(text)) {
+    const core = stripJosa(word.core);
+    if (actionNouns.has(core) && !found.includes(core)) found.push(core);
+  }
+  return found.map((noun) => ({ text: noun + "하다", why: `명사 \`${noun}\`${fitJosa(noun, "을")} 동사 어근으로 되돌린다` }));
+}
+
+/** @param {string} register */
+export function endingRepeatCandidates(register) {
+  const target = REGISTERS.includes(register) ? register : HAPNIDA;
+  return ENDING_CANDIDATES[target].map(([text, why]) => ({ text, why }));
+}
+
+/** @param {string} text @param {string} surface @param {string} reduced */
+function reducedPassiveText(text, surface, reduced) {
+  const prefix = surface.slice(0, -1);
+  let start = 0;
+  while ((start = text.indexOf(prefix, start)) >= 0) {
+    const tailAt = start + prefix.length;
+    const tail = text[tailAt];
+    if (!tail || !hangul.isSyllable(tail)) {
+      start += 1;
+      continue;
+    }
+    const [initial, vowel, final] = hangul.split(tail);
+    if (initial !== 12 || ![hangul.IH, hangul.YEO].includes(vowel)) {
+      start += 1;
+      continue;
+    }
+    let replacement;
+    if (vowel === hangul.YEO) {
+      const base = conjugate(reduced);
+      replacement = final ? base.slice(0, -1) + hangul.withFinal(base.at(-1), final) : base;
+    } else if (final === hangul.BIEUP) {
+      const polite = renderPolite(reduced);
+      replacement = polite.slice(0, -2);
+    } else {
+      replacement = final ? reduced.slice(0, -1) + hangul.withFinal(reduced.at(-1), final) : reduced;
+    }
+    return text.slice(0, start) + replacement + text.slice(tailAt + 1);
+  }
+  return null;
+}
+
+/** polite는 공개 함수가 아니므로 합니다체 활용에서 니다만 뗀다. @param {string} reduced */
+function renderPolite(reduced) {
+  const last = hangul.finalOf(reduced.at(-1));
+  if (last === hangul.NONE || last === hangul.RIEUL) {
+    const stem = last === hangul.RIEUL ? reduced.slice(0, -1) + hangul.withFinal(reduced.at(-1), hangul.NONE) : reduced;
+    return stem.slice(0, -1) + hangul.withFinal(stem.at(-1), hangul.BIEUP) + "니다";
+  }
+  return reduced + "습니다";
+}
+
+/** @param {string} text @param {string[]} passives */
+export function doublePassiveCandidates(text, passives) {
+  const candidates = [];
+  const seen = new Set();
+  for (const surface of passives) {
+    const voice = decomposePassive(surface);
+    if (!voice || voice.reduced === null) continue;
+    const candidateText = reducedPassiveText(text, surface, voice.reduced);
+    if (candidateText === null || seen.has(candidateText)) continue;
+    seen.add(candidateText);
+    candidates.push({ text: candidateText, why: `\`${surface}\`의 피동 겹을 하나로 줄인다` });
+  }
+  return candidates;
+}

package/src/rules/shared/dictionaryRule.js

@@ -1,5 +1,6 @@
 // @ts-check
 /** 사전 규칙의 공통 구현. cliche, translationese, redundantPair, japaneseLoan 이 사전 이름만 바꿔 쓴다. */
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { ERROR, SENTENCE, finding } from "../finding.js";
 
 /**
@@ -9,16 +10,25 @@ import { ERROR, SENTENCE, finding } from "../finding.js";
  * @param {string} [severity]
  * @returns {import("../finding.js").Finding[]}
  */
+/** 문장 시작부터 걸린 자리까지의 줄바꿈 수. 뜻은 파이썬 rules/shared/dictionaryRule.py 가 소유한다. @param {string} text */
+function countNewlines(text) {
+  let count = 0;
+  for (const ch of text) if (ch === "\n") count += 1;
+  return count;
+}
+
 export function dictionaryFindings(doc, dictionary, ruleName, severity = ERROR) {
   const findings = [];
   for (const sentence of doc.sentences) {
     for (const match of sentence.matches) {
       if (match.dictionary !== dictionary) continue;
-      const fix = match.fix !== null ? sentence.text.slice(0, match.start) + match.fix + sentence.text.slice(match.end) : null;
+      // 낱말만 갈아 끼우면 뒤에 붙은 조사가 틀어진다. `이슈로` 를 `쟁점로` 로 내밀던 자리다
+      const tail = sentence.text.slice(match.end);
+      const fix = match.fix !== null ? sentence.text.slice(0, match.start) + match.fix + fitJosa(match.fix, tail) : null;
       findings.push(
         finding(
           ruleName,
-          sentence.line,
+          sentence.line + countNewlines(sentence.text.slice(0, match.start)),
           sentence.text,
           `\`${match.text}\` ${match.why} (${match.source})`,
           fix,

package/src/rules/shared/localAntecedent.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { overlap, topicsOf } from "../../fingerprint/topics.js";
+
+/** @param {import("../../fingerprint/build.js").SentencePrint} sentence */
+export function hasLocalAntecedent(sentence) {
+  const marker = sentence.deixis[0];
+  const start = sentence.text.indexOf(marker);
+  const before = start > 0 ? topicsOf(sentence.text.slice(0, start)) : new Set();
+  if (marker.startsWith("이것")) return before.size > 0;
+  if (marker.startsWith("해당 ") || marker.startsWith("이러한 ")) return overlap(before, topicsOf(marker)) > 0;
+  return false;
+}