hanlint 0.0.9 → 0.0.12

package/src/config/patch.js

@@ -0,0 +1,48 @@
+// @ts-check
+/** 이유가 붙은 정확 국소 Patch 입력 계약. */
+import { sha256 } from "../digest.js";
+
+/** @param {unknown} value @param {string} where */
+function checkedString(value, where) {
+  if (typeof value !== "string" || !value || value !== value.trim()) {
+    throw new Error(`${where} 는 양끝 공백 없는 문자열이다`);
+  }
+  if (value !== value.normalize("NFC")) throw new Error(`${where} 는 NFC 문자열이어야 한다`);
+  return value;
+}
+
+export class Patch {
+  /** @param {string} reason @param {string} before @param {string} after */
+  constructor(reason, before, after) {
+    this.reason = checkedString(reason, "reason");
+    this.before = checkedString(before, "before");
+    this.after = checkedString(after, "after");
+    if (this.before === this.after) throw new Error("patch before 와 after 는 달라야 한다");
+    Object.freeze(this);
+  }
+
+  /** @param {unknown} raw */
+  static fromMapping(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("patch 는 JSON 객체다");
+    const data = /** @type {Record<string, unknown>} */ (raw);
+    const expected = ["reason", "before", "after"];
+    const unknown = Object.keys(data).filter((key) => !expected.includes(key)).sort();
+    const missing = expected.filter((key) => !(key in data)).sort();
+    if (unknown.length) throw new Error(`patch 의 모르는 키: ${unknown.join(", ")}`);
+    if (missing.length) throw new Error(`patch 의 빠진 키: ${missing.join(", ")}`);
+    return new Patch(
+      /** @type {string} */ (data.reason),
+      /** @type {string} */ (data.before),
+      /** @type {string} */ (data.after),
+    );
+  }
+
+  get digest() {
+    const encoded = JSON.stringify({ after: this.after, before: this.before, reason: this.reason });
+    return sha256(encoded);
+  }
+
+  asDict() {
+    return { reason: this.reason, before: this.before, after: this.after };
+  }
+}

package/src/config/readerContract.js

@@ -0,0 +1,245 @@
+// @ts-check
+/** 모델과 실행 환경에 독립적인 최소 Reader Contract와 정확 Patch. */
+import { sha256 } from "../digest.js";
+
+export const CONTRACT_VERSION = 1;
+export const LATEST_CONTRACT_VERSION = 2;
+export const CONTRACT_VERSIONS = Object.freeze([CONTRACT_VERSION, LATEST_CONTRACT_VERSION]);
+
+/** @param {unknown} value @param {string} where */
+function checkedString(value, where) {
+  if (typeof value !== "string" || !value || value !== value.trim()) {
+    throw new Error(`${where} 는 양끝 공백 없는 문자열이다`);
+  }
+  if (value !== value.normalize("NFC")) throw new Error(`${where} 는 NFC 문자열이어야 한다`);
+  return value;
+}
+
+/** @param {unknown} value @param {string} where @param {boolean} [allowEmpty] */
+function checkedStrings(value, where, allowEmpty = false) {
+  if (!Array.isArray(value) || (!allowEmpty && !value.length)) {
+    throw new Error(`${where} 는 ${allowEmpty ? "문자열 배열" : "비지 않은 문자열 배열"}이다`);
+  }
+  const found = value.map((item, index) => checkedString(item, `${where} ${index + 1}번째`));
+  if (new Set(found).size !== found.length) throw new Error(`${where} 에 같은 값이 두 번 있다`);
+  return found;
+}
+
+/** 파이썬 문자열 순서와 같은 코드 포인트 순서. @param {string} left @param {string} right */
+function compareText(left, right) {
+  const leftPoints = [...left].map((value) => /** @type {number} */ (value.codePointAt(0)));
+  const rightPoints = [...right].map((value) => /** @type {number} */ (value.codePointAt(0)));
+  const limit = Math.min(leftPoints.length, rightPoints.length);
+  for (let index = 0; index < limit; index += 1) {
+    if (leftPoints[index] !== rightPoints[index]) return leftPoints[index] - rightPoints[index];
+  }
+  return leftPoints.length - rightPoints.length;
+}
+
+/** @param {string} text */
+function digest(text) {
+  return sha256(text);
+}
+
+export class Contract {
+  /** @param {string} reader @param {string} goal @param {string[]} facts @param {number} [version] */
+  constructor(reader, goal, facts, version = CONTRACT_VERSION) {
+    if (!Number.isInteger(version) || version !== CONTRACT_VERSION) {
+      throw new Error(`reader contract version 은 ${CONTRACT_VERSION}이다: ${version}`);
+    }
+    this.reader = checkedString(reader, "reader");
+    this.goal = checkedString(goal, "goal");
+    this.facts = Object.freeze(checkedStrings(facts, "facts"));
+    this.version = version;
+    Object.freeze(this);
+  }
+
+  /** @param {unknown} raw */
+  static fromMapping(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("reader contract 는 JSON 객체다");
+    const data = /** @type {Record<string, unknown>} */ (raw);
+    const expected = ["version", "reader", "goal", "facts"];
+    const unknown = Object.keys(data).filter((key) => !expected.includes(key)).sort();
+    const missing = expected.filter((key) => !(key in data)).sort();
+    if (unknown.length) throw new Error(`reader contract 의 모르는 키: ${unknown.join(", ")}`);
+    if (missing.length) throw new Error(`reader contract 의 빠진 키: ${missing.join(", ")}`);
+    return new Contract(
+      /** @type {string} */ (data.reader),
+      /** @type {string} */ (data.goal),
+      /** @type {string[]} */ (data.facts),
+      /** @type {number} */ (data.version),
+    );
+  }
+
+  get text() {
+    return [this.reader, this.goal, ...this.facts].join("\n");
+  }
+
+  get digest() {
+    return digest(JSON.stringify({ facts: this.facts, goal: this.goal, reader: this.reader, version: this.version }));
+  }
+
+  asDict() {
+    return { version: this.version, reader: this.reader, goal: this.goal, facts: [...this.facts] };
+  }
+}
+
+export class ProtectedSurface {
+  /** @param {string[]} [numbers] @param {string[]} [urls] @param {string[]} [code] @param {string[]} [links] */
+  constructor(numbers = [], urls = [], code = [], links = []) {
+    this.numbers = Object.freeze(checkedStrings(numbers, "surface.numbers", true).sort(compareText));
+    this.urls = Object.freeze(checkedStrings(urls, "surface.urls", true).sort(compareText));
+    this.code = Object.freeze(checkedStrings(code, "surface.code", true).sort(compareText));
+    this.links = Object.freeze(checkedStrings(links, "surface.links", true).sort(compareText));
+    Object.freeze(this);
+  }
+
+  /** @param {unknown} raw */
+  static fromMapping(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("surface 는 JSON 객체다");
+    const data = /** @type {Record<string, unknown>} */ (raw);
+    const expected = ["numbers", "urls", "code", "links"];
+    const unknown = Object.keys(data).filter((key) => !expected.includes(key)).sort();
+    const missing = expected.filter((key) => !(key in data)).sort();
+    if (unknown.length) throw new Error(`surface 의 모르는 키: ${unknown.join(", ")}`);
+    if (missing.length) throw new Error(`surface 의 빠진 키: ${missing.join(", ")}`);
+    return new ProtectedSurface(
+      /** @type {string[]} */ (data.numbers),
+      /** @type {string[]} */ (data.urls),
+      /** @type {string[]} */ (data.code),
+      /** @type {string[]} */ (data.links),
+    );
+  }
+
+  get text() {
+    return [
+      ...this.numbers,
+      ...this.urls,
+      ...this.code.map((value) => `\`${value}\``),
+      ...this.links.map((value) => `[](${value})`),
+    ].join("\n");
+  }
+
+  asDict() {
+    return { numbers: [...this.numbers], urls: [...this.urls], code: [...this.code], links: [...this.links] };
+  }
+}
+
+export class Outline {
+  /** @param {number} level @param {string[]} headings */
+  constructor(level, headings) {
+    if (!Number.isInteger(level) || level < 1 || level > 6) throw new Error(`outline.level 은 1~6 정수다: ${level}`);
+    this.level = level;
+    this.headings = Object.freeze(checkedStrings(headings, "outline.headings"));
+    Object.freeze(this);
+  }
+
+  /** @param {unknown} raw */
+  static fromMapping(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("outline 은 JSON 객체다");
+    const data = /** @type {Record<string, unknown>} */ (raw);
+    const expected = ["level", "headings"];
+    const unknown = Object.keys(data).filter((key) => !expected.includes(key)).sort();
+    const missing = expected.filter((key) => !(key in data)).sort();
+    if (unknown.length) throw new Error(`outline 의 모르는 키: ${unknown.join(", ")}`);
+    if (missing.length) throw new Error(`outline 의 빠진 키: ${missing.join(", ")}`);
+    return new Outline(/** @type {number} */ (data.level), /** @type {string[]} */ (data.headings));
+  }
+
+  asDict() {
+    return { level: this.level, headings: [...this.headings] };
+  }
+}
+
+export class ContractV2 {
+  /** @param {string} reader @param {string} goal @param {string[]} facts @param {ProtectedSurface | Record<string, unknown>} surface @param {Outline | Record<string, unknown>} outline @param {number} [version] */
+  constructor(reader, goal, facts, surface, outline, version = LATEST_CONTRACT_VERSION, lockedFacts = [], editPolicy = {}) {
+    if (!Number.isInteger(version) || version !== LATEST_CONTRACT_VERSION) {
+      throw new Error(`reader contract version 은 ${LATEST_CONTRACT_VERSION}다: ${version}`);
+    }
+    this.reader = checkedString(reader, "reader");
+    this.goal = checkedString(goal, "goal");
+    this.facts = Object.freeze(checkedStrings(facts, "facts", true));
+    this.surface = surface instanceof ProtectedSurface ? surface : ProtectedSurface.fromMapping(surface);
+    this.outline = outline instanceof Outline ? outline : Outline.fromMapping(outline);
+    this.lockedFacts = Object.freeze(checkedStrings(lockedFacts, "lockedFacts", true));
+    if (this.lockedFacts.some((fact) => !this.facts.includes(fact))) throw new Error("lockedFacts must select approved facts");
+    if (!editPolicy || typeof editPolicy !== "object" || Array.isArray(editPolicy)) throw new Error("editPolicy must be an object");
+    this.editPolicy = Object.freeze(Object.fromEntries(Object.entries(editPolicy).sort(([a], [b]) => compareText(a, b)).map(([rule, limits]) => {
+      if (!rule || rule !== rule.trim()) throw new Error("editPolicy requires rule names");
+      if (!limits || typeof limits !== "object" || Array.isArray(limits) || Object.keys(limits).sort().join(",") !== "maxChars,maxLines") {
+        throw new Error("editPolicy requires maxChars and maxLines");
+      }
+      if (Object.values(limits).some((n) => !Number.isInteger(n) || n < 1)) throw new Error("editPolicy limits must be positive integers");
+      return [rule, Object.freeze({maxChars: limits.maxChars, maxLines: limits.maxLines})];
+    })));
+    this.version = version;
+    Object.freeze(this);
+  }
+
+  /** @param {unknown} raw */
+  static fromMapping(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("reader contract 는 JSON 객체다");
+    const data = /** @type {Record<string, unknown>} */ (raw);
+    const expected = ["version", "reader", "goal", "facts", "surface", "outline"];
+    const unknown = Object.keys(data).filter((key) => !expected.includes(key) && !["lockedFacts", "editPolicy"].includes(key)).sort();
+    const missing = expected.filter((key) => !(key in data)).sort();
+    if (unknown.length) throw new Error(`reader contract 의 모르는 키: ${unknown.join(", ")}`);
+    if (missing.length) throw new Error(`reader contract 의 빠진 키: ${missing.join(", ")}`);
+    return new ContractV2(
+      /** @type {string} */ (data.reader),
+      /** @type {string} */ (data.goal),
+      /** @type {string[]} */ (data.facts),
+      /** @type {Record<string, unknown>} */ (data.surface),
+      /** @type {Record<string, unknown>} */ (data.outline),
+      /** @type {number} */ (data.version),
+      Object.hasOwn(data, "lockedFacts") ? data.lockedFacts : [],
+      Object.hasOwn(data, "editPolicy") ? data.editPolicy : {},
+    );
+  }
+
+  get text() {
+    return [this.reader, this.goal, ...this.facts, this.surface.text].filter(Boolean).join("\n");
+  }
+
+  get digest() {
+    const encoded = {
+      ...(Object.keys(this.editPolicy).length ? {editPolicy: this.editPolicy} : {}),
+      facts: this.facts,
+      goal: this.goal,
+      ...(this.lockedFacts.length ? {lockedFacts: this.lockedFacts} : {}),
+      outline: { headings: this.outline.headings, level: this.outline.level },
+      reader: this.reader,
+      surface: {
+        code: this.surface.code,
+        links: this.surface.links,
+        numbers: this.surface.numbers,
+        urls: this.surface.urls,
+      },
+      version: this.version,
+    };
+    return digest(JSON.stringify(encoded));
+  }
+
+  asDict() {
+    return {
+      version: this.version,
+      reader: this.reader,
+      goal: this.goal,
+      facts: [...this.facts],
+      surface: this.surface.asDict(),
+      outline: this.outline.asDict(),
+      ...(this.lockedFacts.length ? {lockedFacts: [...this.lockedFacts]} : {}),
+      ...(Object.keys(this.editPolicy).length ? {editPolicy: this.editPolicy} : {}),
+    };
+  }
+}
+
+/** @param {unknown} raw */
+export function parseContract(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("reader contract 는 JSON 객체다");
+  const version = /** @type {Record<string, unknown>} */ (raw).version;
+  if (version === CONTRACT_VERSION) return Contract.fromMapping(raw);
+  if (version === LATEST_CONTRACT_VERSION) return ContractV2.fromMapping(raw);
+  throw new Error(`reader contract version 은 ${CONTRACT_VERSIONS.join(",")} 가운데 하나다: ${version}`);
+}

package/src/config/settings.js

@@ -12,9 +12,11 @@ import { projectPatches } from "../data/patches.js";
  * 글의 종류마다 처음부터 끄고 시작할 규칙. 정본은 파이썬 config/settings.py 의 PRESETS 다.
  * @type {Record<string, string[]>}
  */
+// 화면의 글에서만 켜는 것. 산문의 모든 종류가 처음부터 끈다. 파이썬 settings.py 의 SCREEN 과 같다.
+const SCREEN = ["screenNarration", "screenSentence", "screenTone"];
 export const PRESETS = {
-  blog: [],
-  report: ["noQuestion", "firstResultDistance", "introImage", "moreLater", "numberOrphan"],
+  blog: [...SCREEN],
+  report: ["noQuestion", "firstResultDistance", "introImage", "moreLater", "numberOrphan", ...SCREEN],
   docs: [
     "noQuestion",
     "firstResultDistance",
@@ -25,6 +27,7 @@ export const PRESETS = {
     "numberOrphan",
     "duplicateBlock",
     "headingUniform",
+    ...SCREEN,
   ],
 };
 // 서사 글에서만 끄는 것. 설명글의 전제 (독자가 문장 사이 이유를 따라간다, 말끝을 맺는다) 가 장면과
@@ -38,6 +41,74 @@ PRESETS.guide = [...PRESETS.blog, ...REFERENCE];
 PRESETS.essay = [...PRESETS.report, ...NARRATIVE];
 PRESETS.fiction = [...PRESETS.report, ...NARRATIVE];
 PRESETS.encyclopedia = [...PRESETS.docs, ...ENCYCLOPEDIC];
+// 대화 답변에서 끄는 것. 글의 짜임을 재는 규칙은 글 한 편을 전제한다. 파이썬 settings.py 의 CONVERSATION 과 같다.
+const CONVERSATION = [
+  "countMismatch",
+  "duplicateBlock",
+  "factListParagraph",
+  "firstResultDistance",
+  "headingSentence",
+  "headingSkip",
+  "headingUniform",
+  "inputFileSource",
+  "installImport",
+  "introLong",
+  "keywordMissing",
+  "noQuestion",
+  "outsideProfile",
+  "paraFragment",
+  "platformApi",
+  "promiseRecall",
+  "sectionNoProse",
+];
+PRESETS.chat = [...CONVERSATION, ...SCREEN];
+// 화면의 글에서 끄는 것. 문장과 문단과 글의 짜임을 재는 규칙은 화면의 글 한 마디에 전제가 없다. 파이썬 settings.py 의 SCREEN_OFF 와 같다.
+const SCREEN_OFF = [
+  "cliche",
+  "connectorRepeat",
+  "danglingDeixis",
+  "deixis",
+  "doubleNegative",
+  "draftHistory",
+  "endingRepeat",
+  "euiChain",
+  "fillerOpener",
+  "imperativePeriod",
+  "longSentence",
+  "negationRedefine",
+  "nounPile",
+  "numberOrphan",
+  "outsideProfile",
+  "factListParagraph",
+  "paraFragment",
+  "blockUnread",
+  "bridgeRepeat",
+  "emojiBullet",
+  "headingSentence",
+  "headingSkip",
+  "headingUniform",
+  "introImage",
+  "introLong",
+  "loneSubheading",
+  "moreLater",
+  "sectionNoProse",
+  "countMismatch",
+  "enoughOnce",
+  "fieldEcho",
+  "keywordHeading",
+  "keywordMissing",
+  "noQuestion",
+  "promiseRecall",
+  "tableOddCell",
+  "duplicateBlock",
+  "firstResultDistance",
+  "inputFileSource",
+  "installImport",
+  "platformApi",
+];
+PRESETS.screen = SCREEN_OFF;
+/** enforceStyle 에 넣을 수 있는 규칙. 파이썬 settings.py 의 ENFORCEABLE 과 같다. */
+export const ENFORCEABLE = ["noQuestion", "nounPile", "screenNarration", "screenTone"];
 
 /** 프리셋 → 견줄 프로파일의 종류. 정본은 파이썬 config/settings.py 의 PROFILE_OF 다. @type {Record<string, string>} */
 export const PROFILE_OF = {
@@ -48,6 +119,8 @@ export const PROFILE_OF = {
   essay: "essay",
   fiction: "fiction",
   encyclopedia: "encyclopedia",
+  chat: null,
+  screen: null,
 };
 
 export const PRESET_NAMES = Object.keys(PRESETS);
@@ -57,6 +130,7 @@ export const DEFAULT_PRESET = PRESET_NAMES[0];
 /**
  * @typedef {object} Config
  * @property {string} preset 글의 종류. PRESETS 가 정한 규칙을 처음부터 끈다
+ * @property {string[]} enforceStyle
  * @property {Set<string>} disable 끌 규칙 이름
  * @property {string | null} keywordField
  * @property {string[]} introFields
@@ -96,6 +170,7 @@ export function defaultConfig() {
   return {
     preset: DEFAULT_PRESET,
     disable: new Set(),
+    enforceStyle: [],
     keywordField: null,
     introFields: [],
     endingFields: [],
@@ -133,12 +208,12 @@ export function defaultConfig() {
 
 /** @param {Config} config @param {string} ruleName */
 export function enabled(config, ruleName) {
-  return !config.disable.has(ruleName) && !PRESETS[config.preset].includes(ruleName);
+  return !config.disable.has(ruleName) && (!PRESETS[config.preset].includes(ruleName) || config.enforceStyle.includes(ruleName));
 }
 
 /** 지금 꺼져 있는 규칙 이름. 프리셋이 끈 것과 disable 이 끈 것을 합친다. @param {Config} config */
 export function offRules(config) {
-  return [...new Set([...PRESETS[config.preset], ...config.disable])].sort();
+  return [...new Set([...PRESETS[config.preset].filter((name) => !config.enforceStyle.includes(name)), ...config.disable])].sort();
 }
 
 /** @param {Record<string, unknown>} data @returns {Config} */
@@ -155,6 +230,11 @@ export function configFromMapping(data) {
         throw new Error(`preset 은 ${PRESET_NAMES.join(", ")} 가운데 하나다: ${JSON.stringify(value)}`);
       }
       config.preset = /** @type {string} */ (value);
+    } else if (key === "enforceStyle") {
+      if (!Array.isArray(value) || value.some((name) => !ENFORCEABLE.includes(name))) {
+        throw new Error(`enforceStyle 은 ${ENFORCEABLE.join(", ")}의 배열이다`);
+      }
+      config.enforceStyle = [...value];
     } else if (key === "dictionary") {
       config.dictionary = { .../** @type {Record<string, unknown[]>} */ (value) };
     } else if (key === "exemplars") {

package/src/data/load.js

@@ -3,13 +3,8 @@
  * data 폴더를 읽는다. 파이썬 정본의 투영이라 파일 모양이 같다. txt 는 한 줄에 항목 하나, json 은 toml 을 옮긴 것.
  * 한 번 읽은 것은 기억한다.
  */
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
 import { compile } from "../regex.js";
-
-const DATA_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "data");
+import { readData } from "./read.js";
 /** @type {Map<string, unknown>} */
 const cache = new Map();
 
@@ -26,7 +21,7 @@ function cached(key, make) {
 
 /** @param {string} name */
 export function readText(name) {
-  return readFileSync(join(DATA_DIR, name), "utf-8");
+  return readData(name);
 }
 
 /** `#` 으로 시작하면 주석, 빈 줄은 무시. @param {string} name @returns {string[]} */

package/src/data/profiles.js

@@ -3,7 +3,7 @@
  * 참조 분포 (프로파일) 의 자료형과 읽기. 파이썬 data/profiles.py 와 같다. 종류별 프로파일은 profiles.json (투영) 에서,
  * 사용자 프로파일은 `hanlint profile build` 가 만든 파일에서 읽는다. 히스토그램은 정확한 계수라 두 판의 셈이 같다.
  */
-import { readFileSync } from "node:fs";
+import { readExternal } from "./read.js";
 
 import { readText } from "./load.js";
 
@@ -36,6 +36,10 @@ export const TYPE_LABELS = {
  * @property {number} sentences
  * @property {number} paragraphs
  * @property {Map<string, Histogram>} sentence
+ * @property {Map<string, Histogram>} paragraph
+ * @property {Histogram | null} endingRuns
+ * @property {Record<string, number>} endingTransitions
+ * @property {Record<string, Record<string, number>>} rates
  * @property {string} label
  */
 
@@ -62,6 +66,10 @@ function profileFromDict(kind, data) {
   for (const [name, value] of Object.entries(/** @type {Record<string, Record<string, unknown>>} */ (data.sentence))) {
     sentence.set(name, histogramFromDict(value));
   }
+  const paragraph = new Map();
+  for (const [name, value] of Object.entries(/** @type {Record<string, Record<string, unknown>>} */ (data.paragraph))) {
+    paragraph.set(name, histogramFromDict(value));
+  }
   const documents = Number(data.documents);
   return {
     kind,
@@ -69,6 +77,10 @@ function profileFromDict(kind, data) {
     sentences: Number(data.sentences),
     paragraphs: Number(data.paragraphs),
     sentence,
+    paragraph,
+    endingRuns: data.endingRuns ? histogramFromDict(/** @type {Record<string, unknown>} */ (data.endingRuns)) : null,
+    endingTransitions: { .../** @type {Record<string, number>} */ (data.endingTransitions ?? {}) },
+    rates: { .../** @type {Record<string, Record<string, number>>} */ (data.rates ?? {}) },
     label: TYPE_LABELS[kind] ?? `참조 글 ${documents}편`,
   };
 }
@@ -91,7 +103,7 @@ const users = new Map();
 export function userProfile(path) {
   let profile = users.get(path);
   if (!profile) {
-    const data = JSON.parse(readFileSync(path, "utf-8"));
+    const data = JSON.parse(readExternal(path));
     if (data.version !== PROFILE_VERSION || !("profile" in data)) {
       throw new Error(`프로파일 파일이 아니다: ${path}. hanlint profile build 로 다시 만든다`);
     }

package/src/data/read.js

@@ -0,0 +1,21 @@
+// @ts-check
+/** 같은 자료를 Node 파일 또는 브라우저 배포 묶음에서 읽는다. */
+const isNode = typeof process === "object" && Boolean(process.versions?.node);
+const fileSystem = isNode ? await import("node:fs") : null;
+const files = isNode ? null : await fetch(new URL("../../data/siteData.json", import.meta.url)).then((response) => {
+  if (!response.ok) throw new Error("검사 자료를 불러오지 못했습니다. 새로고침해 주세요.");
+  return response.json();
+});
+
+/** @param {string} name @returns {string} */
+export function readData(name) {
+  if (fileSystem) return fileSystem.readFileSync(new URL(`../../data/${name}`, import.meta.url), "utf8");
+  if (typeof files[name] !== "string") throw new Error(`검사 자료가 없습니다: ${name}`);
+  return files[name];
+}
+
+/** @param {string} path @returns {string} */
+export function readExternal(path) {
+  if (!fileSystem) throw new Error("파일 경로 읽기는 Node에서 지원합니다. 브라우저에는 텍스트를 전달해 주세요.");
+  return fileSystem.readFileSync(path, "utf8");
+}

package/src/digest.js

@@ -0,0 +1,44 @@
+// @ts-check
+/** FIPS 180-4 SHA-256. 동기 공개 계약을 Node와 브라우저에서 같은 UTF-8 해시로 유지한다. */
+// 상수와 라운드의 출처: https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf (4.2.2, 6.2).
+const WORDS = [
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];
+const rotate = (value, shift) => (value >>> shift) | (value << (32 - shift));
+
+/** @param {string} text @returns {string} */
+export function sha256(text) {
+  const bytes = new TextEncoder().encode(text);
+  const buffer = new Uint8Array(Math.ceil((bytes.length + 9) / 64) * 64);
+  buffer.set(bytes);
+  buffer[bytes.length] = 0x80;
+  const view = new DataView(buffer.buffer);
+  view.setUint32(buffer.length - 8, Math.floor(bytes.length / 0x20000000));
+  view.setUint32(buffer.length - 4, bytes.length * 8);
+  const hash = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < buffer.length; offset += 64) {
+    for (let index = 0; index < 16; index++) words[index] = view.getUint32(offset + index * 4);
+    for (let index = 16; index < 64; index++) {
+      const left = words[index - 15], right = words[index - 2];
+      const first = rotate(left, 7) ^ rotate(left, 18) ^ (left >>> 3);
+      const second = rotate(right, 17) ^ rotate(right, 19) ^ (right >>> 10);
+      words[index] = words[index - 16] + first + words[index - 7] + second;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let index = 0; index < 64; index++) {
+      const first = h + (rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25)) + ((e & f) ^ (~e & g)) + WORDS[index] + words[index];
+      const second = (rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22)) + ((a & b) ^ (a & c) ^ (b & c));
+      [a, b, c, d, e, f, g, h] = [(first + second) | 0, a, b, c, (d + first) | 0, e, f, g];
+    }
+    [a, b, c, d, e, f, g, h].forEach((value, index) => { hash[index] = (hash[index] + value) | 0; });
+  }
+  return hash.map((value) => (value >>> 0).toString(16).padStart(8, "0")).join("");
+}

package/src/fingerprint/codeMarkers.js

@@ -13,7 +13,7 @@ const READS = new RegExp(
 const OPENS = new RegExp("\\bopen" + QUOTED + "\\s*(?:,\\s*(?:mode\\s*=\\s*)?[\"']([^\"']*)[\"'])?", "g");
 const WRITES = new RegExp(
   "\\b(?:to_csv|to_excel|to_parquet|to_json|to_sql|write_csv|write_parquet|write_json|write_ndjson|sink_parquet|sink_csv|" +
-    "write_text|write_bytes|savefig|save|imwrite|savetxt|dump)" + QUOTED,
+    "write_text|write_bytes|savefig|save|imwrite|savetxt|dump|ExcelWriter)" + QUOTED,
   "g",
 );
 const SHELL_WRITES = /(?:>>?|-o|-O|--output|Out-File)\s*["']?([\w./\\-]+\.[A-Za-z0-9]+)/g;

package/src/fingerprint/dictionaries.js

@@ -12,6 +12,9 @@ export const DICTIONARY_FILES = {
   spacing: "spacing.toml",
   confusable: "confusable.toml",
   easyWords: "easyWords.toml",
+  screenSentence: "screenSentence.toml",
+  screenNarration: "screenNarration.toml",
+  screenTone: "screenTone.toml",
 };
 const GROUP_REF = /\$(\d)/g;
 const FINALS = { ㄴ: 4, ㄹ: 8 };