@uiwwsw/hangulscript 0.0.0-stage → 0.5.0

package/dist/index.js

@@ -0,0 +1,181 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { compileSource } from './transformer.js';
+
+const require = createRequire(import.meta.url);
+let tsModuleCache;
+let defaultCompilerOptions;
+
+function loadTypeScriptModule() {
+  if (tsModuleCache) {
+    return tsModuleCache;
+  }
+  let typescript;
+  try {
+    typescript = require('typescript');
+  } catch (initialError) {
+    const globalCandidate = path.join(process.execPath, '..', '..', 'lib', 'node_modules', 'typescript');
+    try {
+      typescript = require(globalCandidate);
+    } catch (fallbackError) {
+      throw new Error('TypeScript 모듈을 불러올 수 없습니다. Bun 또는 Node 환경에서 TypeScript를 설치해주세요.');
+    }
+  }
+  tsModuleCache = typescript.default ?? typescript;
+  return tsModuleCache;
+}
+
+function getDefaultCompilerOptions(ts) {
+  if (!defaultCompilerOptions) {
+    defaultCompilerOptions = {
+      allowNonTsExtensions: true,
+      noEmit: true,
+      module: ts.ModuleKind.NodeNext,
+      moduleResolution: ts.ModuleResolutionKind.NodeNext,
+      target: ts.ScriptTarget.ES2020,
+      strict: true,
+      esModuleInterop: true
+    };
+  }
+  return defaultCompilerOptions;
+}
+
+function createLintHost(ts, compilerOptions, filePath, sourceText) {
+  const resolvedFilePath = path.resolve(filePath);
+  const baseHost = ts.createCompilerHost(compilerOptions, true);
+  const sourceFile = ts.createSourceFile(
+    resolvedFilePath,
+    sourceText,
+    compilerOptions.target ?? ts.ScriptTarget.ES2020,
+    true,
+    ts.ScriptKind.TS
+  );
+
+  const getSourceFile = baseHost.getSourceFile.bind(baseHost);
+  const fileExists = baseHost.fileExists.bind(baseHost);
+  const readFile = baseHost.readFile.bind(baseHost);
+
+  baseHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+    if (path.resolve(fileName) === resolvedFilePath) {
+      return shouldCreateNewSourceFile ? ts.createSourceFile(
+        resolvedFilePath,
+        sourceText,
+        languageVersion,
+        true,
+        ts.ScriptKind.TS
+      ) : sourceFile;
+    }
+    return getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+  };
+
+  baseHost.fileExists = (fileName) => {
+    if (path.resolve(fileName) === resolvedFilePath) {
+      return true;
+    }
+    return fileExists(fileName);
+  };
+
+  baseHost.readFile = (fileName) => {
+    if (path.resolve(fileName) === resolvedFilePath) {
+      return sourceText;
+    }
+    return readFile(fileName);
+  };
+
+  return baseHost;
+}
+
+function formatDiagnostics(ts, diagnostics) {
+  if (diagnostics.length === 0) {
+    return '';
+  }
+  const formatHost = {
+    getCanonicalFileName: (fileName) => fileName,
+    getCurrentDirectory: () => process.cwd(),
+    getNewLine: () => '\n'
+  };
+  return ts.formatDiagnosticsWithColorAndContext(diagnostics, formatHost);
+}
+
+export function compileString(source) {
+  return compileSource(source);
+}
+
+export async function compileFile(inputPath, outputPath) {
+  const source = await readFile(inputPath, 'utf8');
+  const compiled = compileSource(source);
+  await mkdir(path.dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, compiled, 'utf8');
+  return compiled;
+}
+
+export async function compileFileToDefaultDestination(inputPath) {
+  const parsed = path.parse(inputPath);
+  const outputPath = path.join(parsed.dir, `${parsed.name}.ts`);
+  await compileFile(inputPath, outputPath);
+  return outputPath;
+}
+
+export function lintSource(source, filePath = 'input.hgs', compilerOptions) {
+  const ts = loadTypeScriptModule();
+  const options = compilerOptions ?? getDefaultCompilerOptions(ts);
+  const compiled = compileSource(source);
+  const host = createLintHost(ts, options, filePath, compiled);
+  const program = ts.createProgram([path.resolve(filePath)], options, host);
+  const diagnostics = ts.getPreEmitDiagnostics(program);
+  return {
+    diagnostics,
+    formattedDiagnostics: formatDiagnostics(ts, diagnostics),
+    hasErrors: diagnostics.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)
+  };
+}
+
+export async function lintFile(inputPath, compilerOptions) {
+  const source = await readFile(inputPath, 'utf8');
+  return lintSource(source, inputPath, compilerOptions);
+}
+
+export { compileSource };
+
+/** Compile through TypeScript once, emitting executable JS and declarations in memory. */
+export function buildSource(source, filePath = 'input.hgs') {
+  const ts = loadTypeScriptModule();
+  const virtualPath = path.resolve(filePath).replace(/\.(?:hgs|ks)$/i, '') + '.ts';
+  const compiled = compileSource(source);
+  const options = {
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    strict: true,
+    declaration: true,
+    noEmitOnError: true,
+    skipLibCheck: true
+  };
+  const host = createLintHost(ts, options, virtualPath, compiled);
+  const files = new Map();
+  host.writeFile = (name, content) => files.set(name, content);
+  const program = ts.createProgram([virtualPath], options, host);
+  const diagnostics = ts.getPreEmitDiagnostics(program);
+  if (diagnostics.some(d => d.category === ts.DiagnosticCategory.Error)) {
+    throw new Error(formatDiagnostics(ts, diagnostics));
+  }
+  const emitted = program.emit();
+  if (emitted.emitSkipped) throw new Error(formatDiagnostics(ts, emitted.diagnostics) || '빌드에 실패했습니다.');
+  return {
+    javascript: files.get(virtualPath.replace(/\.ts$/, '.js')) ?? '',
+    declaration: files.get(virtualPath.replace(/\.ts$/, '.d.ts')) ?? ''
+  };
+}
+
+export async function buildFile(inputPath, outputDirectory = path.dirname(inputPath)) {
+  const source = await readFile(inputPath, 'utf8');
+  const result = buildSource(source, inputPath);
+  const base = path.parse(inputPath).name;
+  await mkdir(outputDirectory, { recursive: true });
+  const javascriptPath = path.join(outputDirectory, base + '.js');
+  const declarationPath = path.join(outputDirectory, base + '.d.ts');
+  await writeFile(javascriptPath, result.javascript, 'utf8');
+  await writeFile(declarationPath, result.declaration, 'utf8');
+  return { ...result, javascriptPath, declarationPath };
+}

package/dist/sentences.js

@@ -0,0 +1,103 @@
+import { uiRuntime } from './ui.js';
+// 문장형 v0.1: deterministic indentation grammar, not natural-language inference.
+export function isSentenceSource(source) {
+  return source.split(/\r?\n/).some(line => /^\s*(?:문장으로 시작\s*$|[\p{L}_$][\p{L}\p{N}_$]*(?:은|는)\s+.+이다\s*$|각 .+에서:\s*$|[\p{L}_$][\p{L}\p{N}_$]*\(.*\)를 정의한다:\s*$)/u.test(line));
+}
+
+export const sentenceRuntime = `${uiRuntime}
+
+function 출력(...값: unknown[]): void { console.log(...값); }
+function 길이(값: string | readonly unknown[]): number { return 값.length; }
+function 추가<T>(목록: T[], 값: T): void { 목록.push(값); }
+function 포함<T>(목록: readonly T[], 값: T): boolean { return 목록.includes(값); }
+function 나누기(글: string, 구분: string): string[] { return 글.split(구분); }
+function 잇기(목록: readonly unknown[], 구분 = ""): string { return 목록.join(구분); }
+function 합계(값: readonly number[]): number { return 값.reduce((합, 항목) => 합 + 항목, 0); }
+function 숫자로(값: string | number): number {
+  if (typeof 값 === "string" && 값.trim() === "") throw new Error("빈 문자열은 숫자로 바꿀 수 없습니다.");
+  const 결과 = Number(값);
+  if (!Number.isFinite(결과)) throw new Error("유한한 숫자를 입력하세요.");
+  return 결과;
+}
+function 다듬기(글: string): string { return 글.trim(); }
+function 반올림(값: number, 자리 = 0): number {
+  if (!Number.isFinite(값) || !Number.isInteger(자리) || 자리 < -10 || 자리 > 10) throw new Error("유한한 수와 -10~10 사이의 정수 자리가 필요합니다.");
+  return Math.round(값 * 10 ** 자리) / 10 ** 자리;
+}
+function 평균(목록: readonly number[]): number {
+  if (!목록.length) throw new Error("빈 목록의 평균을 구할 수 없습니다.");
+  return 합계(목록) / 목록.length;
+}
+function 최솟값(목록: readonly number[]): number {
+  if (!목록.length) throw new Error("빈 목록의 최솟값을 구할 수 없습니다.");
+  let 결과 = 목록[0]; for (const 항목 of 목록) if (항목 < 결과) 결과 = 항목;
+  return 결과;
+}
+function 최댓값(목록: readonly number[]): number {
+  if (!목록.length) throw new Error("빈 목록의 최댓값을 구할 수 없습니다.");
+  let 결과 = 목록[0]; for (const 항목 of 목록) if (항목 > 결과) 결과 = 항목;
+  return 결과;
+}
+function 정렬(값: readonly number[]): number[] { return [...값].sort((가, 나) => 가 - 나); }
+function 범위(시작: number, 끝?: number, 간격 = 1): number[] {
+  if (끝 === undefined) { 끝 = 시작; 시작 = 0; }
+  if (!Number.isFinite(시작) || !Number.isFinite(끝) || !Number.isFinite(간격) || 간격 === 0) throw new Error("범위에는 유한한 수와 0이 아닌 간격이 필요합니다.");
+  const 개수 = Math.max(0, Math.ceil((끝 - 시작) / 간격));
+  if (개수 > 100000) throw new Error("범위는 최대 100000개까지 만들 수 있습니다.");
+  return Array.from({ length: 개수 }, (_, 순서) => 시작 + 순서 * 간격);
+}
+`;
+
+export function compileSentences(source, { includeRuntime = true } = {}) {
+  const output = includeRuntime ? [sentenceRuntime] : [];
+  const indents = [0];
+  let needsIndent = false;
+  const lines = source.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    const raw = lines[index];
+    const text = raw.trim();
+    if (!text || text === '문장으로 시작' || text.startsWith('#')) continue;
+    const fail = message => { throw new SyntaxError(`${index + 1}행: ${message}`); };
+    if (/^\s*\t/.test(raw)) fail('들여쓰기는 탭 대신 공백을 사용하세요.');
+    const indent = raw.length - raw.trimStart().length;
+    if (needsIndent) {
+      if (indent <= indents.at(-1)) fail('블록 안의 문장을 들여써 주세요.');
+      indents.push(indent);
+    } else if (indent > indents.at(-1)) fail('예상하지 못한 들여쓰기입니다.');
+    while (indent < indents.at(-1)) { indents.pop(); output.push('}'); }
+    if (indent !== indents.at(-1)) fail('이전 블록과 들여쓰기를 맞춰 주세요.');
+    needsIndent = false;
+    let match;
+    if ((match = text.match(/^(.+\))를 정의한다:$/u))) {
+      // Unannotated parameters are intentionally dynamic, like Python.
+      const signature = match[1].replace(/\((.*)\)$/, (_, params) => '(' + params.split(',').filter(x => x.trim()).map(x => x.includes(':') ? x.trim() : `${x.trim()}: any`).join(', ') + ')');
+      output.push(`function ${signature} {`); needsIndent = true;
+    } else if ((match = text.match(/^("(?:[^"\\]|\\.)*") 버튼을 누르면:$/u))) {
+      output.push(`if (버튼(${match[1]})) {`); needsIndent = true;
+    } else if ((match = text.match(/^각 (.+?)(?:을|를) (.+)에서:$/u))) {
+      if (!/^[\p{L}_$][\p{L}\p{N}_$]*$/u.test(match[1])) fail('반복 변수 이름을 확인하세요.');
+      output.push(`for (const ${match[1]} of ${match[2]}) {`); needsIndent = true;
+    } else if ((match = text.match(/^만약 (.+) (?:이)?라면:$/u))) {
+      output.push(`if (${match[1]}) {`); needsIndent = true;
+    } else if ((match = text.match(/^아니고 (.+) (?:이)?라면:$/u))) {
+      if (output.at(-1) !== '}') fail('아니고 앞에는 조건 블록이 필요합니다.');
+      output.push(`else if (${match[1]}) {`); needsIndent = true;
+    } else if (text === '아니면:') {
+      if (output.at(-1) !== '}') fail('아니면 앞에는 조건 블록이 필요합니다.');
+      output.push('else {'); needsIndent = true;
+    } else if ((match = text.match(/^동안 (.+):$/u))) {
+      output.push(`while (${match[1]}) {`); needsIndent = true;
+    } else if ((match = text.match(/^(.+?)(?:은|는) (.+)이다$/u))) {
+      if (!/^[\p{L}_$][\p{L}\p{N}_$]*$/u.test(match[1])) fail('변수 이름을 확인하세요.');
+      output.push(`let ${match[1]}${match[2].trim() === '[]' ? ': any[]' : ''} = ${match[2]};`);
+    } else if ((match = text.match(/^돌려주기(?: (.+))?$/u))) {
+      output.push(`return ${match[1] ?? ''};`);
+    } else if (text === '멈추기') output.push('break;');
+    else if (text === '계속하기') output.push('continue;');
+    else if (text.endsWith(':')) fail('지원하지 않는 블록 문장입니다.');
+    else output.push(text + (text.endsWith(';') ? '' : ';'));
+  }
+  if (needsIndent) throw new SyntaxError('마지막 블록에 실행할 문장이 필요합니다.');
+  while (indents.length > 1) { indents.pop(); output.push('}'); }
+  return output.join('\n');
+}

package/dist/transformer.d.ts

@@ -0,0 +1,2 @@
+/** Convert keyword-style or sentence-style .hgs source into TypeScript. */
+export function compileSource(source: string): string;

package/dist/transformer.js

@@ -0,0 +1,338 @@
+import ts from 'typescript';
+import { compileSentences, isSentenceSource, sentenceRuntime } from './sentences.js';
+
+const identifierCharRegex = /[\p{L}\p{N}_$]/u;
+
+const KEYWORD_TRANSFORMS = [
+  { match: "내보내기 기본내보내기", replacement: "export default", requiresBoundary: true },
+  { match: "비동기함수", replacement: "async function", requiresBoundary: true },
+  { match: "상수", replacement: "const", requiresBoundary: true },
+  { match: "변수", replacement: "let", requiresBoundary: true },
+  { match: "함수", replacement: "function", requiresBoundary: true },
+  { match: "반환", replacement: "return", requiresBoundary: true },
+  { match: "만약", replacement: "if", requiresBoundary: true },
+  { match: "아니면", replacement: "else", requiresBoundary: true },
+  { match: "반복", replacement: "for", requiresBoundary: true },
+  { match: "동안", replacement: "while", requiresBoundary: true },
+  { match: "실행", replacement: "do", requiresBoundary: true },
+  { match: "참", replacement: "true", requiresBoundary: true },
+  { match: "거짓", replacement: "false", requiresBoundary: true },
+  { match: "비어있음", replacement: "null", requiresBoundary: true },
+  { match: "정의안됨", replacement: "undefined", requiresBoundary: true },
+  { match: "가져오기", replacement: "import", requiresBoundary: true },
+  { match: "에서", replacement: "from", requiresBoundary: true },
+  { match: "프롬", replacement: "from", requiresBoundary: true },
+  { match: "오브", replacement: "of", requiresBoundary: true },
+  { match: "안에", replacement: "in", requiresBoundary: true },
+  { match: "내보내기", replacement: "export", requiresBoundary: true },
+  { match: "스위치", replacement: "switch", requiresBoundary: true },
+  { match: "선택", replacement: "switch", requiresBoundary: true },
+  { match: "케이스", replacement: "case", requiresBoundary: true },
+  { match: "경우", replacement: "case", requiresBoundary: true },
+  { match: "디폴트", replacement: "default", requiresBoundary: true },
+  { match: "기본", replacement: "default", requiresBoundary: true },
+  { match: "중단", replacement: "break", requiresBoundary: true },
+  { match: "멈춤", replacement: "break", requiresBoundary: true },
+  { match: "계속", replacement: "continue", requiresBoundary: true },
+  { match: "마침내", replacement: "finally", requiresBoundary: true },
+  { match: "타입", replacement: "type", requiresBoundary: true },
+  { match: "인터페이스", replacement: "interface", requiresBoundary: true },
+  { match: "구현", replacement: "implements", requiresBoundary: true },
+  { match: "확장", replacement: "extends", requiresBoundary: true },
+  { match: "열거형", replacement: "enum", requiresBoundary: true },
+  { match: "클래스", replacement: "class", requiresBoundary: true },
+  { match: "추상", replacement: "abstract", requiresBoundary: true },
+  { match: "공개", replacement: "public", requiresBoundary: true },
+  { match: "보호", replacement: "protected", requiresBoundary: true },
+  { match: "비공개", replacement: "private", requiresBoundary: true },
+  { match: "정적", replacement: "static", requiresBoundary: true },
+  { match: "읽기전용", replacement: "readonly", requiresBoundary: true },
+  { match: "얻기", replacement: "get", requiresBoundary: true },
+  { match: "설정", replacement: "set", requiresBoundary: true },
+  { match: "선언", replacement: "declare", requiresBoundary: true },
+  { match: "생성자", replacement: "constructor", requiresBoundary: true },
+  { match: "상위", replacement: "super", requiresBoundary: true },
+  { match: "이것", replacement: "this", requiresBoundary: true },
+  { match: "새로운", replacement: "new", requiresBoundary: true },
+  { match: "대기", replacement: "await", requiresBoundary: true },
+  { match: "시도", replacement: "try", requiresBoundary: true },
+  { match: "잡기", replacement: "catch", requiresBoundary: true },
+  { match: "던지기", replacement: "throw", requiresBoundary: true },
+  { match: "양보", replacement: "yield", requiresBoundary: true },
+  { match: "삭제", replacement: "delete", requiresBoundary: true },
+  { match: "타입오브", replacement: "typeof", requiresBoundary: true },
+  { match: "키오브", replacement: "keyof", requiresBoundary: true },
+  { match: "인퍼", replacement: "infer", requiresBoundary: true },
+  { match: "만족", replacement: "satisfies", requiresBoundary: true },
+  { match: "애즈", replacement: "as", requiresBoundary: true },
+  { match: "처럼", replacement: "as", requiresBoundary: true },
+  { match: "이즈", replacement: "is", requiresBoundary: true },
+  { match: "이다", replacement: "is", requiresBoundary: true },
+  { match: "무효", replacement: "void", requiresBoundary: true },
+  { match: "문자열", replacement: "string", requiresBoundary: true },
+  { match: "숫자", replacement: "number", requiresBoundary: true },
+  { match: "불리언", replacement: "boolean", requiresBoundary: true },
+  { match: "아무거나", replacement: "any", requiresBoundary: true },
+  { match: "배열", replacement: "Array", requiresBoundary: true },
+  { match: "레코드", replacement: "Record", requiresBoundary: true },
+  { match: "맵", replacement: "Map", requiresBoundary: true },
+  { match: "세트", replacement: "Set", requiresBoundary: true },
+  { match: "약한맵", replacement: "WeakMap", requiresBoundary: true },
+  { match: "약한세트", replacement: "WeakSet", requiresBoundary: true },
+  { match: "프로미스", replacement: "Promise", requiresBoundary: true },
+  { match: "객체", replacement: "Object", requiresBoundary: true },
+  { match: "날짜", replacement: "Date", requiresBoundary: true },
+  { match: "오류", replacement: "Error", requiresBoundary: true },
+  { match: "정규식", replacement: "RegExp", requiresBoundary: true },
+  { match: "제이슨", replacement: "JSON", requiresBoundary: true },
+  { match: "수학", replacement: "Math", requiresBoundary: true },
+  { match: "콘솔.출력", replacement: "console.log", requiresBoundary: true }
+];
+
+const transformsByFirst = new Map();
+for (const transform of KEYWORD_TRANSFORMS) {
+  const first = transform.match[0];
+  if (!transformsByFirst.has(first)) transformsByFirst.set(first, []);
+  transformsByFirst.get(first).push(transform);
+}
+
+function isIdentifierBoundary(source, index) {
+  if (index <= 0 || index >= source.length) {
+    return true;
+  }
+  const char = source[index - 1];
+  return !identifierCharRegex.test(char);
+}
+
+function isBoundaryAfter(source, index) {
+  if (index >= source.length) {
+    return true;
+  }
+  const char = source[index];
+  return !identifierCharRegex.test(char);
+}
+
+function tryApplyTransform(source, index) {
+  for (const transform of transformsByFirst.get(source[index]) ?? []) {
+    if (!source.startsWith(transform.match, index)) {
+      continue;
+    }
+    if (transform.requiresBoundary) {
+      const beforeOk = isIdentifierBoundary(source, index);
+      const afterOk = isBoundaryAfter(source, index + transform.match.length);
+      if (!beforeOk || !afterOk) {
+        continue;
+      }
+    }
+    return {
+      replacement: transform.replacement,
+      length: transform.match.length
+    };
+  }
+  return null;
+}
+
+function transformKeywords(source) {
+  let result = "";
+  let index = 0;
+  const modeStack = ["code"];
+  const templateExpressionStack = [];
+
+  while (index < source.length) {
+    const mode = modeStack[modeStack.length - 1];
+    const char = source[index];
+
+    if (mode === "code" || mode === "templateExpression") {
+      if (mode === "templateExpression") {
+        if (char === "}") {
+          const info = templateExpressionStack[templateExpressionStack.length - 1];
+          info.depth -= 1;
+          result += char;
+          index += 1;
+          if (info.depth === 0) {
+            templateExpressionStack.pop();
+            modeStack.pop();
+          }
+          continue;
+        }
+        if (char === "{") {
+          const info = templateExpressionStack[templateExpressionStack.length - 1];
+          info.depth += 1;
+          result += char;
+          index += 1;
+          continue;
+        }
+      }
+
+      if (char === "\"") {
+        modeStack.push("doubleQuote");
+        result += char;
+        index += 1;
+        continue;
+      }
+      if (char === "'") {
+        modeStack.push("singleQuote");
+        result += char;
+        index += 1;
+        continue;
+      }
+      if (char === "`") {
+        modeStack.push("template");
+        result += char;
+        index += 1;
+        continue;
+      }
+      if (char === "/") {
+        const next = source[index + 1];
+        if (next === "/") {
+          modeStack.push("lineComment");
+          result += "//";
+          index += 2;
+          continue;
+        }
+        if (next === "*") {
+          modeStack.push("blockComment");
+          result += "/*";
+          index += 2;
+          continue;
+        }
+      }
+
+      const transform = tryApplyTransform(source, index);
+      if (transform) {
+        result += transform.replacement;
+        index += transform.length;
+        continue;
+      }
+
+      result += char;
+      index += 1;
+      continue;
+    }
+
+    if (mode === "singleQuote") {
+      result += char;
+      index += 1;
+      if (char === "\\") {
+        if (index < source.length) {
+          result += source[index];
+          index += 1;
+        }
+        continue;
+      }
+      if (char === "'") {
+        modeStack.pop();
+      }
+      continue;
+    }
+
+    if (mode === "doubleQuote") {
+      result += char;
+      index += 1;
+      if (char === "\\") {
+        if (index < source.length) {
+          result += source[index];
+          index += 1;
+        }
+        continue;
+      }
+      if (char === "\"") {
+        modeStack.pop();
+      }
+      continue;
+    }
+
+    if (mode === "template") {
+      result += char;
+      index += 1;
+      if (char === "\\") {
+        if (index < source.length) {
+          result += source[index];
+          index += 1;
+        }
+        continue;
+      }
+      if (char === "`") {
+        modeStack.pop();
+        continue;
+      }
+      if (char === "$" && source[index] === "{") {
+        result += "{";
+        modeStack.push("templateExpression");
+        templateExpressionStack.push({ depth: 1 });
+        index += 1;
+      }
+      continue;
+    }
+
+    if (mode === "lineComment") {
+      result += char;
+      index += 1;
+      if (char === "\n") {
+        modeStack.pop();
+      }
+      continue;
+    }
+
+    if (mode === "blockComment") {
+      result += char;
+      index += 1;
+      if (char === "*" && source[index] === "/") {
+        result += "/";
+        index += 1;
+        modeStack.pop();
+      }
+      continue;
+    }
+  }
+
+  return result;
+}
+
+// Scan tokens so literals, comments, and nested function bodies stay untouched.
+function fixClassMethods(source) {
+  if (!source.includes('class')) return source;
+  const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, source);
+  const stack = [];
+  const edits = [];
+  let pendingClass = false;
+  let previous = ts.SyntaxKind.Unknown;
+  const templateDepths = [];
+  let braces = 0;
+  for (let token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) {
+    if (token === ts.SyntaxKind.CloseBraceToken && templateDepths.at(-1) === braces) {
+      token = scanner.reScanTemplateToken(false);
+      if (token === ts.SyntaxKind.TemplateTail) templateDepths.pop();
+      continue;
+    }
+    if (token === ts.SyntaxKind.TemplateHead) { templateDepths.push(braces); continue; }
+    if (token === ts.SyntaxKind.SingleLineCommentTrivia || token === ts.SyntaxKind.MultiLineCommentTrivia ||
+        token === ts.SyntaxKind.WhitespaceTrivia || token === ts.SyntaxKind.NewLineTrivia) continue;
+    if (token === ts.SyntaxKind.ClassKeyword) pendingClass = true;
+    if (token === ts.SyntaxKind.OpenBraceToken) {
+      stack.push(pendingClass ? 'class' : 'block');
+      pendingClass = false;
+      braces++;
+    } else if (token === ts.SyntaxKind.CloseBraceToken) {
+      stack.pop(); braces--;
+    } else if (token === ts.SyntaxKind.FunctionKeyword && stack.at(-1) === 'class' &&
+      [ts.SyntaxKind.OpenBraceToken, ts.SyntaxKind.CloseBraceToken, ts.SyntaxKind.SemicolonToken,
+       ts.SyntaxKind.AsyncKeyword, ts.SyntaxKind.PublicKeyword, ts.SyntaxKind.PrivateKeyword,
+       ts.SyntaxKind.ProtectedKeyword, ts.SyntaxKind.StaticKeyword].includes(previous)) {
+      const start = scanner.getTokenPos();
+      let end = scanner.getTextPos();
+      while (source[end] === ' ' || source[end] === '\t') end++;
+      edits.push([start, end]);
+    }
+    previous = token;
+  }
+  for (const [start, end] of edits.reverse()) source = source.slice(0, start) + source.slice(end);
+  return source;
+}
+
+export function compileSource(source) {
+  const sentenceMode = isSentenceSource(source);
+  if (sentenceMode) source = compileSentences(source, { includeRuntime: false });
+  const transformed = fixClassMethods(transformKeywords(source));
+  return sentenceMode ? sentenceRuntime + '\n' + transformed : transformed;
+}

package/dist/ui.js

@@ -0,0 +1,49 @@
+// A data-only UI protocol: the host renders descriptors, never user HTML or code.
+export function createUIBridge(values = {}, action = '') {
+  const elements = [];
+  const labels = new Set();
+  const text = value => String(value).slice(0, 2000);
+  function add(type, label, extra = {}) {
+    label = text(label);
+    if (!label || labels.has(label)) throw new Error('화면 요소의 이름은 비어 있거나 중복될 수 없습니다.');
+    if (elements.length >= 40) throw new Error('화면에는 최대 40개 요소를 만들 수 있습니다.');
+    labels.add(label);
+    const item = { type, label, ...extra };
+    elements.push(item);
+    return item;
+  }
+  return {
+    number(label, initial = 0) {
+      const raw = Object.hasOwn(values, label) ? values[label] : initial;
+      if (String(raw).trim() === '' || !Number.isFinite(Number(raw))) throw new Error(`${text(label)}: 올바른 숫자를 입력하세요.`);
+      const value = Number(raw); add('number', label, { value }); return value;
+    },
+    text(label, initial = '') {
+      const value = text(Object.hasOwn(values, label) ? values[label] : initial);
+      add('text', label, { value }); return value;
+    },
+    select(label, options, initial = options?.[0]) {
+      if (!Array.isArray(options) || !options.length || options.length > 30) throw new Error('선택 항목은 1~30개가 필요합니다.');
+      options = options.map(text);
+      const value = text(Object.hasOwn(values, label) ? values[label] : initial);
+      if (!options.includes(value)) throw new Error(`${text(label)}: 목록에서 항목을 선택하세요.`);
+      add('select', label, { value, options }); return value;
+    },
+    button(label) { add('button', label); return action === label; },
+    show(label, value) { add('result', label, { value: text(value) }); },
+    snapshot() { return elements; }
+  };
+}
+
+export const uiRuntime = `
+function 화면연결(): { number: (이름: string, 기본값?: number) => number; text: (이름: string, 기본값?: string) => string; select: (이름: string, 항목: string[], 기본값?: string) => string; button: (이름: string) => boolean; show: (이름: string, 값: unknown) => void } {
+  const 연결 = (globalThis as any).__hangulUI;
+  if (!연결) throw new Error("화면 함수는 한글스크립트 UI 실행 환경에서 사용하세요.");
+  return 연결;
+}
+function 숫자입력(이름: string, 기본값 = 0): number { return 화면연결().number(이름, 기본값); }
+function 글자입력(이름: string, 기본값 = ""): string { return 화면연결().text(이름, 기본값); }
+function 선택입력(이름: string, 항목: string[], 기본값 = 항목[0]): string { return 화면연결().select(이름, 항목, 기본값); }
+function 버튼(이름: string): boolean { return 화면연결().button(이름); }
+function 보여주기(이름: string, 값: unknown): void { 화면연결().show(이름, 값); }
+`;

package/dist/vite.d.ts

@@ -0,0 +1,6 @@
+/** Transform .hgs imports at build time. Place before the React or Vue plugin. */
+export default function hangulscript(): {
+  name: string;
+  enforce: 'pre';
+  transform(source: string, id: string): { code: string; map: null } | null;
+};