@uiwwsw/hangulscript 0.5.0 → 0.7.0

package/dist/sentences.js

@@ -1,103 +1,144 @@
-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));
-}
+import { sentenceRuntime } from './runtime.js';
+import { expression, typeExpression, signature, statement } from './expressions.js';
+export { sentenceRuntime } from './runtime.js';
 
-export const sentenceRuntime = `${uiRuntime}
+const identifier = /^[\p{L}_$][\p{L}\p{N}_$]*$/u;
+const functionName = /^[\p{L}_$][\p{L}\p{N}_$]*(?:<.+>)?$/u;
+const obsolete = /^(?:상수|변수|함수|반환|클래스|가져오기|내보내기|반복|비동기함수|스위치|선택|케이스|경우|인터페이스|열거형|시도|잡기|마침내|던지기|선언|추상)(?:\s|[({*])|^콘솔\.출력/u;
 
-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;
+export function compileSentences(source, { includeRuntime = true, withMapping = false } = {}) {
+  const output = [];
+  const lineMap = [];
+  let currentLine = 0;
+  const push = code => { output.push(code); lineMap.push(...code.split('\n').map(() => currentLine)); };
+  if (includeRuntime) push(sentenceRuntime);
+  const frames = [{ indent: 0, kind: 'root' }];
+  let pending = null;
   const lines = source.split(/\r?\n/);
+  const inside = kind => {
+    for (let i = frames.length - 1; i > 0; i--) {
+      if (kind.includes(frames[i].kind)) return true;
+      if (['function', 'method', 'generator', 'async'].includes(frames[i].kind)) return false;
+    }
+    return false;
+  };
   for (let index = 0; index < lines.length; index++) {
+    currentLine = index + 1;
     const raw = lines[index];
     const text = raw.trim();
-    if (!text || text === '문장으로 시작' || text.startsWith('#')) continue;
+    if (!text || text.startsWith('#')) continue;
     const fail = message => { throw new SyntaxError(`${index + 1}행: ${message}`); };
+    if (/^문장으로 시작[.]?$/.test(text)) fail('시작 표기는 사용하지 않습니다. 첫 문장부터 작성하세요.');
     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 (pending) {
+      if (indent <= frames.at(-1).indent) fail('블록 안의 문장을 들여써 주세요.');
+      frames.push({ ...pending, indent }); pending = null;
+    } else if (indent > frames.at(-1).indent) fail('예상하지 못한 들여쓰기입니다.');
+    let closed;
+    while (indent < frames.at(-1).indent) {
+      closed = frames.pop();
+      push(closed.kind === 'case' ? 'break; }' : '}');
+    }
+    if (indent !== frames.at(-1).indent) fail('이전 블록과 들여쓰기를 맞춰 주세요.');
+    const parent = frames.at(-1).kind;
+    const open = (code, kind) => { push(code + ' {'); pending = { kind }; };
+    const emit = code => push(code);
+    const exp = value => expression(value);
+    const top = () => { if (parent !== 'root') fail('가져오기·공개·타입 선언은 파일의 최상위에 작성하세요.'); };
+    let m;
+    try {
+      if (closed?.kind === 'do' && !/^.+인 동안 반복한다$/.test(text)) fail('먼저 실행한다 블록 뒤에 「조건인 동안 반복한다」가 필요합니다.');
+      if (obsolete.test(text)) fail('키워드형 문법은 제거됐습니다. 문장형으로 작성하세요.');
+      if ((m = text.match(/^(비동기로 |차례로 )?(.+?)\((.*)\)를 정의한다:$/u))) {
+        if (!functionName.test(m[2])) fail('함수 이름을 확인하세요.');
+        const method = parent === 'class';
+        const kind = m[1] === '비동기로 ' ? 'async' : m[1] === '차례로 ' ? 'generator' : method ? 'method' : 'function';
+        const prefix = (kind === 'async' ? 'async ' : '') + (method ? (kind === 'generator' ? '*' : '') : (kind === 'generator' ? 'function* ' : 'function '));
+        open(`${prefix}${m[2]}(${signature('(' + m[3] + ')', m[2])})`, kind);
+      } else if ((m = text.match(/^생성할 때\((.*)\):$/u))) {
+        if (parent !== 'class') fail('생성할 때는 클래스 안에서 사용하세요.');
+        open(`constructor(${signature('(' + m[1] + ')')})`, 'method');
+      } else if ((m = text.match(/^(.+?)을 읽으면:$/u))) {
+        if (parent !== 'class' || !identifier.test(m[1])) fail('읽기 속성은 클래스 안에 작성하세요.');
+        open(`get ${m[1]}()`, 'method');
+      } else if ((m = text.match(/^(.+?)을 바꾸면\((.*)\):$/u))) {
+        if (parent !== 'class' || !identifier.test(m[1])) fail('쓰기 속성은 클래스 안에 작성하세요.');
+        open(`set ${m[1]}(${signature('(' + m[2] + ')')})`, 'method');
+      } else if ((m = text.match(/^(?:(.+?)을 이어받아 )?(.+?) 클래스를 정의한다:$/u))) {
+        if (!functionName.test(m[2])) fail('클래스 이름을 확인하세요.');
+        open(`class ${m[2]}${m[1] ? ' extends ' + m[1] : ''}`, 'class');
+      } else if ((m = text.match(/^(.+?) 자료형을 정의한다:$/u))) {
+        top(); if (!functionName.test(m[1])) fail('자료형 이름을 확인하세요.'); open(`interface ${m[1]}`, 'interface');
+      } else if ((m = text.match(/^(.+?) 타입은 (.+)이다$/u))) {
+        top(); if (!functionName.test(m[1])) fail('타입 이름을 확인하세요.'); emit(`type ${m[1]} = ${typeExpression(m[2])};`);
+      } else if ((m = text.match(/^(.+?) 열거값을 정의한다:$/u))) {
+        top(); if (!identifier.test(m[1])) fail('열거값 이름을 확인하세요.'); open(`enum ${m[1]}`, 'enum');
+      } else if (parent === 'enum') {
+        if (!identifier.test(text)) fail('열거값 항목에는 이름 하나를 작성하세요.'); emit(text + ',');
+      } else if ((m = text.match(/^(.+)에서 (.+?)(?:을|를) 가져온다$/u))) {
+        top(); if (!/^(?:".*"|'.*')$/.test(m[1])) fail('모듈 경로를 따옴표로 감싸세요.');
+        const binding = m[2].replace(/^모두를 (.+)로$/, '* as $1'); emit(`import ${binding} from ${m[1]};`);
+      } else if ((m = text.match(/^(.+?)(?:을|를) 기본으로 공개한다$/u))) {
+        top(); emit(`export default ${exp(m[1])};`);
+      } else if ((m = text.match(/^(.+?)(?:을|를) 공개한다$/u))) {
+        top(); emit(`export ${m[1].startsWith('{') ? m[1] : '{ ' + m[1] + ' }'};`);
+      } else if ((m = text.match(/^("(?:[^"\\]|\\.)*") 버튼을 누르면:$/u))) {
+        open(`if (버튼(${m[1]}))`, 'if');
+      } else if ((m = text.match(/^각 (.+?)(?:을|를) (.+)에서:$/u))) {
+        if (!identifier.test(m[1])) fail('반복 변수 이름을 확인하세요.'); open(`for (const ${m[1]} of ${exp(m[2])})`, 'loop');
+      } else if ((m = text.match(/^만약 (.+) (?:이)?라면:$/u))) {
+        open(`if (${exp(m[1])})`, 'if');
+      } else if ((m = text.match(/^아니고 (.+) (?:이)?라면:$/u))) {
+        if (!['if', 'elseif'].includes(closed?.kind)) fail('아니고 앞에는 조건 블록이 필요합니다.'); open(`else if (${exp(m[1])})`, 'elseif');
+      } else if (text === '아니면:') {
+        if (!['if', 'elseif'].includes(closed?.kind)) fail('아니면 앞에는 조건 블록이 필요합니다.'); open('else', 'else');
+      } else if ((m = text.match(/^동안 (.+):$/u))) {
+        open(`while (${exp(m[1])})`, 'loop');
+      } else if (text === '먼저 실행한다:') {
+        open('do', 'do');
+      } else if ((m = text.match(/^(.+)인 동안 반복한다$/u))) {
+        if (closed?.kind !== 'do') fail('먼저 실행한다 블록 뒤에 작성하세요.'); emit(`while (${exp(m[1])});`);
+      } else if ((m = text.match(/^(.+)에 따라:$/u))) {
+        open(`switch (${exp(m[1])})`, 'switch');
+      } else if ((m = text.match(/^(.+)인 경우:$/u))) {
+        if (parent !== 'switch') fail('경우는 값에 따라 블록 안에 작성하세요.'); open(`case ${exp(m[1])}:`, 'case');
+      } else if (text === '그 밖의 경우:') {
+        if (parent !== 'switch') fail('그 밖의 경우는 값에 따라 블록 안에 작성하세요.'); open('default:', 'case');
+      } else if (text === '시도한다:') {
+        open('try', 'try');
+      } else if ((m = text.match(/^(.+?)(?:을|를) 잡으면:$/u))) {
+        if (closed?.kind !== 'try' || !identifier.test(m[1])) fail('잡으면 앞에는 시도한다 블록이 필요합니다.'); open(`catch (${m[1]})`, 'catch');
+      } else if (text === '마지막으로:') {
+        if (!['try', 'catch'].includes(closed?.kind)) fail('마지막으로 앞에는 시도한다 또는 잡으면 블록이 필요합니다.'); open('finally', 'finally');
+      } else if ((m = text.match(/^오류를 일으킨다 (.+)$/u))) {
+        emit(`throw ${exp(m[1])};`);
+      } else if ((m = text.match(/^(.+?)(?:은|는) (.+?)(이다|으로 고정한다)$/u))) {
+        const binding = m[1].match(/^([\p{L}_$][\p{L}\p{N}_$]*)(?::\s*(.+))?$/u);
+        if (!binding) fail('변수 이름과 타입을 확인하세요.');
+        const type = binding[2] ? ': ' + typeExpression(binding[2]) : m[2] === '[]' ? ': any[]' : '';
+        emit(`${parent === 'class' ? '' : m[3] === '으로 고정한다' ? 'const ' : 'let '}${binding[1]}${type} = ${exp(m[2])};`);
+      } else if (['class', 'interface'].includes(parent) && (m = text.match(/^([\p{L}_$][\p{L}\p{N}_$]*\??): (.+)$/u))) {
+        emit(`${m[1]}: ${typeExpression(m[2])};`);
+      } else if ((m = text.match(/^돌려주기(?: (.+))?$/u))) {
+        if (!frames.some(f => ['function', 'method', 'async', 'generator'].includes(f.kind))) fail('돌려주기는 함수 안에서 사용하세요.'); emit(`return ${m[1] ? exp(m[1]) : ''};`);
+      } else if ((m = text.match(/^내주기 (.+)$/u))) {
+        if (!inside(['generator'])) fail('내주기는 차례로 정의한 함수 안에서 사용하세요.'); emit(`yield ${exp(m[1])};`);
+      } else if (text === '멈추기' || text === '계속하기') {
+        if (!inside(text === '멈추기' ? ['loop', 'do', 'case'] : ['loop', 'do'])) fail('반복 블록 안에서 사용하세요.'); emit(text === '멈추기' ? 'break;' : 'continue;');
+      } else if (text.endsWith(':')) fail('지원하지 않는 블록 문장입니다.');
+      else emit(statement(exp(text)));
+    } catch (error) {
+      if (error.message.startsWith(`${index + 1}행:`)) throw error;
+      fail(error.message);
+    }
+  }
+  if (pending) throw new SyntaxError('마지막 블록에 실행할 문장이 필요합니다.');
+  while (frames.length > 1) {
+    const frame = frames.pop();
+    if (frame.kind === 'do') throw new SyntaxError('먼저 실행한다 블록 뒤에 반복 조건이 필요합니다.');
+    push(frame.kind === 'case' ? 'break; }' : '}');
   }
-  if (needsIndent) throw new SyntaxError('마지막 블록에 실행할 문장이 필요합니다.');
-  while (indents.length > 1) { indents.pop(); output.push('}'); }
-  return output.join('\n');
+  const code = output.join('\n');
+  return withMapping ? { code, lineMap } : code;
 }

package/dist/transformer.d.ts

@@ -1,2 +1,5 @@
 /** Convert keyword-style or sentence-style .hgs source into TypeScript. */
 export function compileSource(source: string): string;
+
+export interface MappedSource { code: string; lineMap: number[]; }
+export function compileMappedSource(source: string): MappedSource;

package/dist/transformer.js

@@ -1,338 +1,13 @@
-import ts from 'typescript';
-import { compileSentences, isSentenceSource, sentenceRuntime } from './sentences.js';
+import { compileSentences } 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;
+/** HangulScript has one syntax: indentation-based Korean sentences. */
+export function compileSource(source) {
+  if (typeof source !== 'string') throw new TypeError('한글스크립트 소스는 문자열이어야 합니다.');
+  return compileSentences(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;
+/** Generated TypeScript lines map to 1-based HGS lines; runtime lines map to zero. */
+export function compileMappedSource(source) {
+  if (typeof source !== 'string') throw new TypeError('한글스크립트 소스는 문자열이어야 합니다.');
+  return compileSentences(source, { withMapping: true });
 }

package/dist/vite.js

@@ -1,21 +1,28 @@
 import ts from 'typescript';
-import { compileSource } from './transformer.js';
+import { analyzeSource } from './checker.js';
+import { HangulScriptError } from './diagnostics.js';
 
-/** Build-time .hgs imports for Vite projects, including React and Vue. */
+/** Semantic checking is mandatory in both Vite development and production builds. */
 export default function hangulscript() {
+  const files = new Map();
   return {
     name: 'hangulscript',
     enforce: 'pre',
+    buildStart() { files.clear(); },
+    watchChange(id, change) { if (change.event === 'delete') files.delete(id.split('?')[0]); },
     transform(source, id) {
-      if (!/\.hgs$/.test(id.split('?')[0]) || /[?&](?:raw|url)(?:[=&]|$)/.test(id)) return null;
-      const compiled = compileSource(source);
-      const result = ts.transpileModule(compiled, {
-        fileName: id.replace(/\.hgs(?:\?.*)?$/, '.ts'),
-        compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext, sourceMap: false },
-        reportDiagnostics: true
-      });
-      const errors = (result.diagnostics ?? []).filter(d => d.category === ts.DiagnosticCategory.Error);
-      if (errors.length) throw new Error(errors.map(d => ts.flattenDiagnosticMessageText(d.messageText, '\n')).join('\n'));
+      const filePath = id.split('?')[0];
+      if (!/\.hgs$/.test(filePath) || /[?&](?:raw|url)(?:[=&]|$)/.test(id)) return null;
+      files.set(filePath, source);
+      const checked = analyzeSource(source, filePath, { files, allFiles: true });
+      if (typeof this?.addWatchFile === 'function') for (const doc of checked.documents.values()) this.addWatchFile(doc.filePath);
+      if (checked.hasErrors) {
+        const error = new HangulScriptError(checked.diagnostics);
+        const first = checked.diagnostics.find(d => d.severity === 'error');
+        if (typeof this?.error === 'function') return this.error({ message: error.message, id: first.filePath, loc: { file: first.filePath, line: first.line, column: first.column - 1 } });
+        throw error;
+      }
+      const result = ts.transpileModule(checked.compiled, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext } });
       return { code: result.outputText, map: null };
     }
   };