@uiwwsw/hangulscript 0.5.0 → 0.7.0

package/dist/diagnostics.js

@@ -0,0 +1,61 @@
+import ts from 'typescript';
+
+const hints = {
+  2304: '이름을 먼저 선언했는지 확인하세요.',
+  2307: '모듈 경로와 파일이 있는지 확인하세요.',
+  2322: '선언한 타입과 대입한 값의 타입을 확인하세요.',
+  2339: '이 값에 해당 속성이나 메서드가 있는지 확인하세요.',
+  2345: '함수에 전달한 값의 타입을 확인하세요.',
+  2554: '함수에 전달하는 인자의 개수를 확인하세요.',
+  7006: '공개 함수의 매개변수 타입을 명시하세요.'
+};
+
+export class HangulScriptError extends Error {
+  constructor(diagnostics) {
+    super(formatSourceDiagnostics(diagnostics));
+    this.name = 'HangulScriptError';
+    this.diagnostics = diagnostics;
+  }
+}
+
+export function syntaxDiagnostic(error, source, filePath) {
+  const lines = source.split(/\r?\n/);
+  const match = error.message.match(/^(\d+)행: /);
+  const line = match ? Number(match[1]) : Math.max(1, lines.findLastIndex(line => line.trim()) + 1);
+  const text = lines[line - 1] ?? '';
+  return { filePath, line, column: text.length - text.trimStart().length + 1, length: Math.max(1, text.trim().length), code: 'HGS1001', message: error.message.replace(/^\d+행: /, ''), severity: 'error' };
+}
+
+export function mapDiagnostic(diagnostic, documents) {
+  const file = diagnostic.file;
+  const position = file && diagnostic.start !== undefined ? file.getLineAndCharacterOfPosition(diagnostic.start) : { line: 0, character: 0 };
+  const document = file && documents.get(file.fileName);
+  let line = position.line + 1;
+  let column = position.character + 1;
+  let length = diagnostic.length ?? 1;
+  if (document) {
+    line = document.lineMap[position.line] || 1;
+    const original = document.source.split(/\r?\n/)[line - 1] ?? '';
+    const token = file.text.slice(diagnostic.start, diagnostic.start + length);
+    const generatedLine = file.text.split('\n')[position.line] ?? '';
+    const occurrence = token ? generatedLine.slice(0, position.character).split(token).length - 1 : 0;
+    let found = -1;
+    for (let i = 0; i <= occurrence; i++) {
+      const next = original.indexOf(token, found + 1);
+      if (next < 0) break;
+      found = next;
+    }
+    column = found >= 0 ? found + 1 : original.length - original.trimStart().length + 1;
+    length = Math.max(1, Math.min(length, original.length - column + 1));
+  }
+  const detail = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+  return {
+    filePath: document?.filePath ?? file?.fileName ?? 'input.hgs', line, column, length,
+    code: diagnostic.code, message: hints[diagnostic.code] ? `${hints[diagnostic.code]}\n${detail}` : detail,
+    severity: diagnostic.category === ts.DiagnosticCategory.Error ? 'error' : 'warning'
+  };
+}
+
+export function formatSourceDiagnostics(diagnostics) {
+  return diagnostics.map(d => `${d.filePath}:${d.line}:${d.column} [${typeof d.code === 'number' ? 'TS' : ''}${d.code}] ${d.message}`).join('\n');
+}

package/dist/editor.d.ts

@@ -0,0 +1,5 @@
+import type { CheckSettings } from './index.js';
+export interface EditorLocation { filePath: string; line: number; column: number; length: number; }
+export interface EditorInspection { hover?: string; definitions: EditorLocation[]; completions: { name: string; detail: string }[]; }
+/** One-based UTF-16 positions. Does not execute source. */
+export function inspectSource(source: string, filePath: string, line: number, column: number, settings?: CheckSettings): EditorInspection;

package/dist/editor.js

@@ -0,0 +1,50 @@
+import ts from 'typescript';
+import path from 'node:path';
+import { analyzeSource } from './checker.js';
+import { mapDiagnostic } from './diagnostics.js';
+
+/** One-based source positions; analysis only, never executes user code. */
+export function inspectSource(source, filePath, line, column, settings = {}) {
+  const analysis = analyzeSource(source, filePath, settings);
+  const file = analysis.program.getSourceFile(analysis.virtualRoot);
+  const document = analysis.documents.get(analysis.virtualRoot);
+  if (!file || !document) return { completions: [], definitions: [] };
+  let target = file;
+  let matched;
+  const original = source.split(/\r?\n/)[line - 1] ?? '';
+  const visit = node => {
+    if (ts.isIdentifier(node)) {
+      const pos = file.getLineAndCharacterOfPosition(node.getStart(file));
+      if (document.lineMap[pos.line] === line) {
+        target = node;
+        const generatedLine = file.text.split('\n')[pos.line];
+        const occurrence = generatedLine.slice(0, pos.character).split(node.text).length - 1;
+        let found = -1;
+        for (let i=0; i<=occurrence; i++) { const next=original.indexOf(node.text,found+1); if(next<0) break; found=next; }
+        if (found >= 0 && column - 1 >= found && column - 1 <= found + node.text.length) matched = node;
+      }
+    }
+    ts.forEachChild(node,visit);
+  };
+  visit(file);
+  const checker = analysis.program.getTypeChecker();
+  target = matched ?? target;
+  const completions = checker.getSymbolsInScope(target, ts.SymbolFlags.Value | ts.SymbolFlags.Type | ts.SymbolFlags.Alias)
+    .filter(symbol => symbol.declarations?.some(d => analysis.documents.has(d.getSourceFile().fileName) && !['화면연결'].includes(symbol.name)))
+    .map(symbol => ({ name: symbol.name, detail: checker.typeToString(checker.getTypeOfSymbolAtLocation(symbol,target)) }));
+  if (!matched) return { completions, definitions: [] };
+  let symbol = checker.getSymbolAtLocation(matched);
+  if (!symbol) return { completions, definitions: [] };
+  if (symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+  const type = checker.typeToString(checker.getTypeOfSymbolAtLocation(symbol,matched),matched,ts.TypeFormatFlags.NoTruncation);
+  const definitions = (symbol.declarations ?? []).flatMap(declaration => {
+    const name = declaration.name ?? declaration;
+    const sourceFile=name.getSourceFile();
+    const doc=analysis.documents.get(sourceFile.fileName);
+    const position=sourceFile.getLineAndCharacterOfPosition(name.getStart(sourceFile));
+    if (!doc || !doc.lineMap[position.line]) return [];
+    const location=mapDiagnostic({file:sourceFile,start:name.getStart(sourceFile),length:name.getWidth(sourceFile),code:0,messageText:'',category:ts.DiagnosticCategory.Message},analysis.documents);
+    return [{filePath:path.resolve(location.filePath),line:location.line,column:location.column,length:location.length}];
+  });
+  return { hover: `${symbol.name}: ${type}`, completions, definitions };
+}

package/dist/emitter.js

@@ -0,0 +1,39 @@
+import ts from 'typescript';
+import path from 'node:path';
+import { analyzeSource } from './checker.js';
+import { HangulScriptError, mapDiagnostic } from './diagnostics.js';
+
+// Keep JavaScript and declaration imports consistent with emitted filenames.
+function rewriteImports(context) {
+  const visit = node => {
+    if (ts.isStringLiteral(node) && node.parent && node.text.endsWith('.hgs') &&
+      ((ts.isImportDeclaration(node.parent) || ts.isExportDeclaration(node.parent)) && node.parent.moduleSpecifier === node ||
+       ts.isCallExpression(node.parent) && node.parent.expression.kind === ts.SyntaxKind.ImportKeyword && node.parent.arguments[0] === node)) {
+      return context.factory.createStringLiteral(node.text.replace(/\.hgs$/, '.js'));
+    }
+    // afterDeclarations nodes do not always carry parent links.
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text.endsWith('.hgs')) {
+      return context.factory.updateImportDeclaration(node, node.modifiers, node.importClause, context.factory.createStringLiteral(node.moduleSpecifier.text.replace(/\.hgs$/, '.js')), node.attributes);
+    }
+    if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text.endsWith('.hgs')) {
+      return context.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, context.factory.createStringLiteral(node.moduleSpecifier.text.replace(/\.hgs$/, '.js')), node.attributes);
+    }
+    return ts.visitEachChild(node, visit, context);
+  };
+  return node => ts.visitNode(node, visit);
+}
+
+export function emitSource(source, filePath) {
+  const result = analyzeSource(source, filePath);
+  if (result.hasErrors) throw new HangulScriptError(result.diagnostics);
+  const files = new Map();
+  const emitted = result.program.emit(undefined, (name, content) => files.set(name, content), undefined, undefined, { before: [rewriteImports], afterDeclarations: [rewriteImports] });
+  if (emitted.emitSkipped) throw new HangulScriptError(emitted.diagnostics.map(d => mapDiagnostic(d, result.documents)));
+  const modules = [...result.documents].map(([virtual, doc]) => ({
+    sourcePath: doc.filePath,
+    javascript: files.get(virtual.replace(/\.ts$/, '.js')) ?? '',
+    declaration: files.get(virtual.replace(/\.ts$/, '.d.ts')) ?? ''
+  }));
+  const root = modules.find(module => module.sourcePath === path.resolve(filePath));
+  return { javascript: root.javascript, declaration: root.declaration, modules };
+}

package/dist/expressions.js

@@ -0,0 +1,59 @@
+import ts from 'typescript';
+
+const literals = new Map([['참', 'true'], ['거짓', 'false'], ['비어있음', 'null'], ['정의안됨', 'undefined'], ['자신', 'this'], ['부모', 'super']]);
+const types = new Map([['숫자', 'number'], ['문자열', 'string'], ['논리', 'boolean'], ['불리언', 'boolean'], ['아무거나', 'any'], ['모름', 'unknown'], ['무효', 'void']]);
+
+function identifiers(source, replacements) {
+  const file = ts.createSourceFile('expression.ts', source, ts.ScriptTarget.Latest, true);
+  const edits = [];
+  const visit = node => {
+    if (ts.isIdentifier(node) && replacements.has(node.text)) {
+      const p = node.parent;
+      const property = (ts.isPropertyAccessExpression(p) && p.name === node) ||
+        ((ts.isPropertyAssignment(p) || ts.isMethodDeclaration(p) || ts.isPropertySignature(p)) && p.name === node);
+      if (!property) edits.push([node.getStart(file), node.end, replacements.get(node.text)]);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(file);
+  for (const [start, end, value] of edits.reverse()) source = source.slice(0, start) + value + source.slice(end);
+  return source;
+}
+
+export function expression(source) {
+  source = source.replace(/^새\s+/, 'new ').replace(/^기다리기\s+/, 'await ');
+  if (/[참거비정자부]/.test(source)) {
+    const prefix = 'const __expression = (';
+    source = identifiers(prefix + source + ');', literals).slice(prefix.length, -2);
+  }
+  return source;
+}
+
+export function typeExpression(source) {
+  const prefix = 'type __Type = ';
+  return identifiers(prefix + source, types).slice(prefix.length);
+}
+
+export function signature(source, name = '__fn') {
+  const file = ts.createSourceFile('signature.ts', `function ${name}${source} {}`, ts.ScriptTarget.Latest, true);
+  const fn = file.statements[0];
+  if (file.parseDiagnostics.length || !ts.isFunctionDeclaration(fn)) throw new SyntaxError('함수 이름·매개변수·타입을 확인하세요.');
+  return fn.parameters.map(param => {
+    let printed = param.getText(file);
+    const start = param.getStart(file);
+    const edits = [];
+    if (param.type) edits.push([param.type.getStart(file) - start, param.type.end - start, typeExpression(param.type.getText(file))]);
+    if (param.initializer) edits.push([param.initializer.getStart(file) - start, param.initializer.end - start, expression(param.initializer.getText(file))]);
+    for (const [from, to, value] of edits.sort((a, b) => b[0] - a[0])) printed = printed.slice(0, from) + value + printed.slice(to);
+    if (!param.type && !param.initializer) printed += param.dotDotDotToken ? ': any[]' : ': any';
+    return printed;
+  }).join(', ');
+}
+
+export function statement(source) {
+  const file = ts.createSourceFile('statement.ts', source, ts.ScriptTarget.Latest, true);
+  if (file.parseDiagnostics.length || file.statements.length !== 1 || !ts.isExpressionStatement(file.statements[0])) {
+    throw new SyntaxError('문장형 구문을 사용하세요. 선언은 「이름은 값이다」, 함수는 「이름(...)를 정의한다:」로 작성합니다.');
+  }
+  return source.replace(/;$/, '') + ';';
+}

package/dist/formatter.d.ts

@@ -0,0 +1,2 @@
+/** Preserve expression/literal contents while normalizing indentation and whitespace. */
+export function formatSource(source: string, options?: { tabSize?: number }): string;

package/dist/formatter.js

@@ -0,0 +1,29 @@
+import { compileSource } from './transformer.js';
+
+/** Normalize indentation and whitespace without rewriting expressions or literals. */
+export function formatSource(source, { tabSize = 4 } = {}) {
+  if (!Number.isInteger(tabSize) || tabSize < 1 || tabSize > 8) throw new RangeError('들여쓰기 폭은 1~8 사이의 정수여야 합니다.');
+  const eol = source.includes('\r\n') ? '\r\n' : '\n';
+  const expanded = source.replace(/^[ \t]*\t[ \t]*/gm, prefix => {
+    let width = 0;
+    for (const c of prefix) width += c === '\t' ? tabSize - width % tabSize : 1;
+    return ' '.repeat(width);
+  });
+  compileSource(expanded); // Refuse to guess the intended structure of invalid code.
+  const levels = [0];
+  const output = [];
+  for (const raw of expanded.split(/\r?\n/)) {
+    const text = raw.trim();
+    if (!text) { if (output.length && output.at(-1) !== '') output.push(''); continue; }
+    const indent = raw.length - raw.trimStart().length;
+    if (text.startsWith('#')) {
+      const depth = levels.filter(level => level < indent).length;
+      output.push(' '.repeat(depth * tabSize) + text); continue;
+    }
+    while (levels.at(-1) > indent) levels.pop();
+    if (indent > levels.at(-1)) levels.push(indent);
+    output.push(' '.repeat((levels.length - 1) * tabSize) + raw.trimStart().trimEnd());
+  }
+  while (output.at(-1) === '') output.pop();
+  return output.length ? output.join(eol) + eol : '';
+}

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export function compileFile(inputPath: string, outputPath: string): Promise<stri
 export function compileFileToDefaultDestination(inputPath: string): Promise<string>;
 export interface LintResult {
   diagnostics: readonly ts.Diagnostic[];
+  sourceDiagnostics: readonly SourceDiagnostic[];
   formattedDiagnostics: string;
   hasErrors: boolean;
 }
@@ -13,3 +14,11 @@ export function lintFile(inputPath: string, compilerOptions?: ts.CompilerOptions
 export interface BuildResult { javascript: string; declaration: string; }
 export function buildSource(source: string, filePath?: string): BuildResult;
 export function buildFile(inputPath: string, outputDirectory?: string): Promise<BuildResult & { javascriptPath: string; declarationPath: string }>;
+
+export interface SourceDiagnostic { filePath: string; line: number; column: number; length: number; code: number | string; message: string; severity: 'error' | 'warning'; }
+export interface CheckSettings { files?: ReadonlyMap<string, string>; allFiles?: boolean; libDirectory?: string; compilerOptions?: ts.CompilerOptions; }
+export function checkSource(source: string, filePath?: string, settings?: CheckSettings): { diagnostics: SourceDiagnostic[]; hasErrors: boolean };
+export function formatSourceDiagnostics(diagnostics: readonly SourceDiagnostic[]): string;
+export class HangulScriptError extends Error { diagnostics: SourceDiagnostic[]; constructor(diagnostics: SourceDiagnostic[]); }
+
+export { formatSource } from './formatter.js';

package/dist/index.js

@@ -1,102 +1,11 @@
 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);
-}
+import { analyzeSource } from './checker.js';
+import { formatSourceDiagnostics } from './diagnostics.js';
+import { emitSource } from './emitter.js';
+export { checkSource } from './checker.js';
+export { HangulScriptError, formatSourceDiagnostics } from './diagnostics.js';
 
 export function compileString(source) {
   return compileSource(source);
@@ -118,16 +27,13 @@ export async function compileFileToDefaultDestination(inputPath) {
 }
 
 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);
+  compileSource(source); // Keep syntax errors explicit for callers of the legacy lint API.
+  const result = analyzeSource(source, filePath, { compilerOptions });
   return {
-    diagnostics,
-    formattedDiagnostics: formatDiagnostics(ts, diagnostics),
-    hasErrors: diagnostics.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)
+    diagnostics: result.nativeDiagnostics,
+    sourceDiagnostics: result.diagnostics,
+    formattedDiagnostics: formatSourceDiagnostics(result.diagnostics),
+    hasErrors: result.hasErrors
   };
 }
 
@@ -140,42 +46,30 @@ 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')) ?? ''
-  };
+  const { javascript, declaration } = emitSource(source, filePath);
+  return { javascript, declaration };
 }
 
 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 };
+  const { javascript, declaration, modules } = emitSource(source, inputPath);
+  const rootDirectory = path.dirname(path.resolve(inputPath));
+  const destinations = modules.map(module => {
+    const relative = path.relative(rootDirectory, module.sourcePath);
+    if (relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) {
+      throw new Error('빌드 입력 파일의 폴더 밖에 있는 .hgs 모듈은 지원하지 않습니다. 공통 상위 폴더에 진입 파일을 두세요.');
+    }
+    const base = path.join(outputDirectory, relative.replace(/\.hgs$/, ''));
+    return { ...module, javascriptPath: base + '.js', declarationPath: base + '.d.ts' };
+  });
+  // Validate the complete graph before writing any output.
+  for (const module of destinations) {
+    await mkdir(path.dirname(module.javascriptPath), { recursive: true });
+    await writeFile(module.javascriptPath, module.javascript, 'utf8');
+    await writeFile(module.declarationPath, module.declaration, 'utf8');
+  }
+  const root = destinations.find(module => module.sourcePath === path.resolve(inputPath));
+  return { javascript, declaration, javascriptPath: root.javascriptPath, declarationPath: root.declarationPath };
 }
+
+export { formatSource } from './formatter.js';

package/dist/loader.js

@@ -0,0 +1,16 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+import { analyzeSource } from './checker.js';
+import { HangulScriptError } from './diagnostics.js';
+export async function load(url, context, nextLoad) {
+  if (url.startsWith('file:') && new URL(url).pathname.endsWith('.hgs')) {
+    const filePath=fileURLToPath(url);
+    const source=await readFile(filePath,'utf8');
+    const result=analyzeSource(source,filePath);
+    if(result.hasErrors) throw new HangulScriptError(result.diagnostics);
+    const compiled=ts.transpileModule(result.compiled,{compilerOptions:{module:ts.ModuleKind.ESNext,target:ts.ScriptTarget.ES2022}}).outputText;
+    return {format:'module',source:compiled,shortCircuit:true};
+  }
+  return nextLoad(url,context);
+}

package/dist/register.js

@@ -0,0 +1,2 @@
+import { register } from 'node:module';
+register('./loader.js',import.meta.url);

package/dist/runtime.js

@@ -0,0 +1,44 @@
+import { uiRuntime } from './ui.js';
+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: 개수 }, (_, 순서) => 시작 + 순서 * 간격);
+}
+`;