@jishaanyazmi/code-script 1.0.0

package/dist/ast.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ast.js.map

package/dist/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":""}

package/dist/compiler-core.d.ts

@@ -0,0 +1,62 @@
+import { ProgramNode, Statement, Expression } from './ast.js';
+interface SemanticError {
+    kind: string;
+    message: string;
+    file: string;
+    line: number;
+    column: number;
+    suggestion?: string;
+}
+interface SemanticWarning {
+    message: string;
+    file: string;
+    line: number;
+    column: number;
+}
+export interface SemanticResult {
+    errors: SemanticError[];
+    warnings: SemanticWarning[];
+}
+export declare class SemanticAnalyzer {
+    private readonly file;
+    private readonly scope;
+    private readonly errors;
+    private readonly warnings;
+    private insideLoop;
+    private insideFunction;
+    constructor(file?: string);
+    analyze(program: ProgramNode): SemanticResult;
+    private err;
+    private warn;
+    private analyzeStatement;
+    private analyzeVarDecl;
+    private analyzeFuncDecl;
+    private analyzeReturn;
+    private analyzeIf;
+    private analyzeSwitch;
+    private analyzeRepeat;
+    private analyzeUntil;
+    private analyzeClass;
+    private analyzeTry;
+    private analyzeExport;
+    private analyzeExpr;
+}
+export declare class Optimizer {
+    optimize(program: ProgramNode): ProgramNode;
+    private optStmt;
+    private optExpr;
+}
+export declare class CodeGenerator {
+    private out;
+    private level;
+    private line;
+    private emit;
+    private indent;
+    private dedent;
+    generate(program: ProgramNode): string;
+    genStmt(stmt: Statement): void;
+    private genBlock;
+    genExpr(expr: Expression): string;
+}
+export {};
+//# sourceMappingURL=compiler-core.d.ts.map

package/dist/compiler-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-core.d.ts","sourceRoot":"","sources":["../src/compiler-core.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,WAAW,EAAE,SAAS,EAAE,UAAU,EAOrC,MAAM,UAAU,CAAA;AAWjB,UAAU,aAAa;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE;AAC1H,UAAU,eAAe;IAAG,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE;AAczF,MAAM,WAAW,cAAc;IAAG,MAAM,EAAE,aAAa,EAAE,CAAC;IAAC,QAAQ,EAAE,eAAe,EAAE,CAAA;CAAE;AAExF,qBAAa,gBAAgB;IAOb,OAAO,CAAC,QAAQ,CAAC,IAAI;IANjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwB;IACjD,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,cAAc,CAAQ;gBAED,IAAI,GAAE,MAAkB;IAErD,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc;IAO7C,OAAO,CAAC,GAAG;IAGX,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,gBAAgB;IAoBxB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,YAAY;IAapB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,WAAW;CAuBtB;AAID,qBAAa,SAAS;IAClB,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW;IAG3C,OAAO,CAAC,OAAO;IAWf,OAAO,CAAC,OAAO;CAoBlB;AAeD,qBAAa,aAAa;IACtB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,KAAK,CAAI;IAEjB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IAEd,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM;IAOtC,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAgE9B,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;CA4BpC"}

package/dist/compiler-core.js

@@ -0,0 +1,577 @@
+// ─── Semantic Analyzer ────────────────────────────────────────────────────────
+const RESERVED = new Set([
+    'grab', 'share', 'make', 'fixed', 'keep', 'do', 'give', 'say', 'check', 'otherwise',
+    'pick', 'when', 'anyway', 'repeat', 'until', 'stop', 'skip', 'type', 'from', 'create',
+    'me', 'parent', 'attempt', 'oops', 'panic', 'done', 'later', 'wait', 'remove', 'kind',
+    'is', 'mine', 'everyone', 'family', 'shared', 'yes', 'no', 'empty', 'unknown'
+]);
+class ScopeManager {
+    constructor() {
+        this.stack = [new Map()];
+    }
+    enter(_type) { this.stack.push(new Map()); }
+    exit() { if (this.stack.length > 1)
+        this.stack.pop(); }
+    define(name, kind, line, column) { this.stack[this.stack.length - 1].set(name, { kind, line, column }); }
+    has(name) { return this.stack[this.stack.length - 1].has(name); }
+    lookup(name) {
+        for (let i = this.stack.length - 1; i >= 0; i--) {
+            const s = this.stack[i].get(name);
+            if (s)
+                return s;
+        }
+        return undefined;
+    }
+}
+export class SemanticAnalyzer {
+    constructor(file = 'unknown') {
+        this.file = file;
+        this.scope = new ScopeManager();
+        this.errors = [];
+        this.warnings = [];
+        this.insideLoop = false;
+        this.insideFunction = false;
+    }
+    analyze(program) {
+        for (const stmt of program.body)
+            this.analyzeStatement(stmt);
+        for (const err of this.errors)
+            console.error(`SemanticError [${err.kind}]\nFile: ${err.file}\nLine: ${err.line}\nColumn: ${err.column}\nMessage: ${err.message}${err.suggestion ? '\nSuggestion: ' + err.suggestion : ''}`);
+        for (const w of this.warnings)
+            console.warn(`Warning\nFile: ${w.file}\nLine: ${w.line}\nMessage: ${w.message}`);
+        return { errors: this.errors, warnings: this.warnings };
+    }
+    err(kind, message, line, column, suggestion) {
+        this.errors.push({ kind, message, file: this.file, line, column, suggestion });
+    }
+    warn(message, line, column) {
+        this.warnings.push({ message, file: this.file, line, column });
+    }
+    analyzeStatement(stmt) {
+        switch (stmt.kind) {
+            case 'VariableDeclaration': return this.analyzeVarDecl(stmt);
+            case 'FunctionDeclaration': return this.analyzeFuncDecl(stmt);
+            case 'ReturnStatement': return this.analyzeReturn(stmt);
+            case 'IfStatement': return this.analyzeIf(stmt);
+            case 'SwitchStatement': return this.analyzeSwitch(stmt);
+            case 'RepeatStatement': return this.analyzeRepeat(stmt);
+            case 'UntilStatement': return this.analyzeUntil(stmt);
+            case 'BreakStatement':
+                if (!this.insideLoop)
+                    this.err('InvalidBreak', '"stop" can only be used inside a loop.', stmt.loc.line, stmt.loc.column);
+                break;
+            case 'ContinueStatement':
+                if (!this.insideLoop)
+                    this.err('InvalidContinue', '"skip" can only be used inside a loop.', stmt.loc.line, stmt.loc.column);
+                break;
+            case 'ClassDeclaration': return this.analyzeClass(stmt);
+            case 'TryStatement': return this.analyzeTry(stmt);
+            case 'ThrowStatement':
+                this.analyzeExpr(stmt.value);
+                break;
+            case 'ExpressionStatement':
+                this.analyzeExpr(stmt.expression);
+                break;
+            case 'ImportDeclaration': break;
+            case 'ExportDeclaration': return this.analyzeExport(stmt);
+        }
+    }
+    analyzeVarDecl(node) {
+        const { name, keyword, value, loc } = node;
+        if (RESERVED.has(name.name)) {
+            this.err('ReservedKeyword', `"${name.name}" is a reserved keyword.`, loc.line, loc.column);
+            return;
+        }
+        if (keyword === 'fixed' && value === null)
+            this.err('UninitializedConstant', `Constant "${name.name}" must be initialized.`, loc.line, loc.column);
+        if (this.scope.has(name.name))
+            this.err('DuplicateDeclaration', `"${name.name}" is already declared.`, loc.line, loc.column);
+        else
+            this.scope.define(name.name, keyword === 'fixed' ? 'constant' : 'variable', loc.line, loc.column);
+        if (value)
+            this.analyzeExpr(value);
+    }
+    analyzeFuncDecl(node) {
+        if (node.name.name && this.scope.has(node.name.name))
+            this.err('DuplicateDeclaration', `Function "${node.name.name}" is already declared.`, node.loc.line, node.loc.column);
+        else if (node.name.name)
+            this.scope.define(node.name.name, 'function', node.loc.line, node.loc.column);
+        this.scope.enter('function');
+        const prev = this.insideFunction;
+        this.insideFunction = true;
+        for (const p of node.params)
+            this.scope.define(p.name, 'parameter', p.loc.line, p.loc.column);
+        for (const s of node.body.body)
+            this.analyzeStatement(s);
+        this.insideFunction = prev;
+        this.scope.exit();
+    }
+    analyzeReturn(node) {
+        if (!this.insideFunction)
+            this.err('InvalidReturn', '"give" can only be used inside a function.', node.loc.line, node.loc.column);
+        if (node.value)
+            this.analyzeExpr(node.value);
+    }
+    analyzeIf(node) {
+        this.analyzeExpr(node.condition);
+        this.scope.enter('block');
+        for (const s of node.consequent.body)
+            this.analyzeStatement(s);
+        this.scope.exit();
+        if (node.alternate) {
+            this.scope.enter('block');
+            for (const s of node.alternate.body)
+                this.analyzeStatement(s);
+            this.scope.exit();
+        }
+    }
+    analyzeSwitch(node) {
+        this.analyzeExpr(node.discriminant);
+        const prev = this.insideLoop;
+        this.insideLoop = true;
+        for (const c of node.cases) {
+            this.analyzeExpr(c.test);
+            this.scope.enter('block');
+            for (const s of c.body.body)
+                this.analyzeStatement(s);
+            this.scope.exit();
+        }
+        if (node.defaultCase) {
+            this.scope.enter('block');
+            for (const s of node.defaultCase.body)
+                this.analyzeStatement(s);
+            this.scope.exit();
+        }
+        this.insideLoop = prev;
+    }
+    analyzeRepeat(node) {
+        this.scope.enter('block');
+        const prev = this.insideLoop;
+        this.insideLoop = true;
+        if (node.init)
+            this.analyzeStatement(node.init);
+        if (node.condition)
+            this.analyzeExpr(node.condition);
+        if (node.update)
+            this.analyzeExpr(node.update);
+        for (const s of node.body.body)
+            this.analyzeStatement(s);
+        this.insideLoop = prev;
+        this.scope.exit();
+    }
+    analyzeUntil(node) {
+        this.analyzeExpr(node.condition);
+        this.scope.enter('block');
+        const prev = this.insideLoop;
+        this.insideLoop = true;
+        for (const s of node.body.body)
+            this.analyzeStatement(s);
+        this.insideLoop = prev;
+        this.scope.exit();
+    }
+    analyzeClass(node) {
+        if (this.scope.has(node.name.name))
+            this.err('DuplicateDeclaration', `Class "${node.name.name}" is already declared.`, node.loc.line, node.loc.column);
+        else
+            this.scope.define(node.name.name, 'class', node.loc.line, node.loc.column);
+        this.scope.enter('class');
+        const prev = this.insideFunction;
+        this.insideFunction = true;
+        for (const m of node.body.members) {
+            this.scope.enter('function');
+            for (const p of m.params)
+                this.scope.define(p.name, 'parameter', p.loc.line, p.loc.column);
+            for (const s of m.body.body)
+                this.analyzeStatement(s);
+            this.scope.exit();
+        }
+        this.insideFunction = prev;
+        this.scope.exit();
+    }
+    analyzeTry(node) {
+        this.scope.enter('block');
+        for (const s of node.body.body)
+            this.analyzeStatement(s);
+        this.scope.exit();
+        if (node.handler) {
+            this.scope.enter('block');
+            this.scope.define(node.handler.param.name, 'variable', node.handler.param.loc.line, node.handler.param.loc.column);
+            for (const s of node.handler.body.body)
+                this.analyzeStatement(s);
+            this.scope.exit();
+        }
+        if (node.finalizer) {
+            this.scope.enter('block');
+            for (const s of node.finalizer.body)
+                this.analyzeStatement(s);
+            this.scope.exit();
+        }
+    }
+    analyzeExport(node) {
+        for (const s of node.specifiers)
+            if (!this.scope.lookup(s.name))
+                this.warn(`Exported name "${s.name}" may not be defined.`, s.loc.line, s.loc.column);
+    }
+    analyzeExpr(expr) {
+        switch (expr.kind) {
+            case 'Identifier': {
+                const builtins = new Set(['say', 'math', 'fs', 'json', 'date', 'console', 'this', 'super']);
+                if (!builtins.has(expr.name) && !this.scope.lookup(expr.name))
+                    this.warn(`"${expr.name}" may not be defined.`, expr.loc.line, expr.loc.column);
+                break;
+            }
+            case 'AssignmentExpression': {
+                if (expr.left.kind === 'Identifier') {
+                    const sym = this.scope.lookup(expr.left.name);
+                    if (sym?.kind === 'constant')
+                        this.err('ConstantReassignment', `Cannot reassign constant "${expr.left.name}".`, expr.loc.line, expr.loc.column);
+                }
+                this.analyzeExpr(expr.left);
+                this.analyzeExpr(expr.right);
+                break;
+            }
+            case 'BinaryExpression':
+            case 'LogicalExpression':
+                this.analyzeExpr(expr.left);
+                this.analyzeExpr(expr.right);
+                break;
+            case 'UnaryExpression':
+                this.analyzeExpr(expr.operand);
+                break;
+            case 'CallExpression':
+                this.analyzeExpr(expr.callee);
+                for (const a of expr.args)
+                    this.analyzeExpr(a);
+                break;
+            case 'MemberExpression':
+                this.analyzeExpr(expr.object);
+                if (expr.computed)
+                    this.analyzeExpr(expr.property);
+                break;
+            case 'ArrayExpression':
+                for (const e of expr.elements)
+                    this.analyzeExpr(e);
+                break;
+            case 'ObjectExpression':
+                for (const p of expr.properties)
+                    this.analyzeExpr(p.value);
+                break;
+            case 'NewExpression':
+                if (!this.scope.lookup(expr.callee.name))
+                    this.warn(`Class "${expr.callee.name}" may not be defined.`, expr.callee.loc.line, expr.callee.loc.column);
+                for (const a of expr.args)
+                    this.analyzeExpr(a);
+                break;
+        }
+    }
+}
+// ─── Optimizer ────────────────────────────────────────────────────────────────
+export class Optimizer {
+    optimize(program) {
+        return { ...program, body: program.body.map(s => this.optStmt(s)).filter(s => !(s.kind === 'ExpressionStatement' && s.expression.kind === 'Literal' && s.expression.value === undefined)) };
+    }
+    optStmt(stmt) {
+        switch (stmt.kind) {
+            case 'VariableDeclaration': return stmt.value ? { ...stmt, value: this.optExpr(stmt.value) } : stmt;
+            case 'ExpressionStatement': return { ...stmt, expression: this.optExpr(stmt.expression) };
+            case 'ReturnStatement': return stmt.value ? { ...stmt, value: this.optExpr(stmt.value) } : stmt;
+            case 'IfStatement': return { ...stmt, condition: this.optExpr(stmt.condition), consequent: { ...stmt.consequent, body: stmt.consequent.body.map(s => this.optStmt(s)) }, alternate: stmt.alternate ? { ...stmt.alternate, body: stmt.alternate.body.map(s => this.optStmt(s)) } : null };
+            case 'RepeatStatement': return { ...stmt, condition: stmt.condition ? this.optExpr(stmt.condition) : null, body: { ...stmt.body, body: stmt.body.body.map(s => this.optStmt(s)) } };
+            case 'UntilStatement': return { ...stmt, condition: this.optExpr(stmt.condition), body: { ...stmt.body, body: stmt.body.body.map(s => this.optStmt(s)) } };
+            default: return stmt;
+        }
+    }
+    optExpr(expr) {
+        if (expr.kind !== 'BinaryExpression')
+            return expr;
+        const left = this.optExpr(expr.left);
+        const right = this.optExpr(expr.right);
+        if (left.kind === 'Literal' && right.kind === 'Literal') {
+            const l = left.value;
+            const r = right.value;
+            if (typeof l === 'number' && typeof r === 'number') {
+                let result = null;
+                switch (expr.operator) {
+                    case '+':
+                        result = l + r;
+                        break;
+                    case '-':
+                        result = l - r;
+                        break;
+                    case '*':
+                        result = l * r;
+                        break;
+                    case '/':
+                        result = r !== 0 ? l / r : null;
+                        break;
+                    case '%':
+                        result = l % r;
+                        break;
+                    case '**':
+                        result = l ** r;
+                        break;
+                    case '>':
+                        result = l > r;
+                        break;
+                    case '<':
+                        result = l < r;
+                        break;
+                    case '>=':
+                        result = l >= r;
+                        break;
+                    case '<=':
+                        result = l <= r;
+                        break;
+                    case '==':
+                        result = l == r;
+                        break;
+                    case '===':
+                        result = l === r;
+                        break;
+                    case '!=':
+                        result = l != r;
+                        break;
+                    case '!==':
+                        result = l !== r;
+                        break;
+                }
+                if (result !== null)
+                    return { kind: 'Literal', value: result, raw: String(result), loc: left.loc };
+            }
+            if (typeof l === 'string' && typeof r === 'string' && expr.operator === '+')
+                return { kind: 'Literal', value: l + r, raw: `"${l + r}"`, loc: left.loc };
+        }
+        return { ...expr, left, right };
+    }
+}
+// ─── Code Generator ───────────────────────────────────────────────────────────
+const KW = {
+    make: 'let', fixed: 'const', keep: 'var', do: 'function', give: 'return',
+    say: 'console.log', check: 'if', otherwise: 'else', pick: 'switch', when: 'case',
+    anyway: 'default', repeat: 'for', until: 'while', stop: 'break', skip: 'continue',
+    type: 'class', from: 'extends', create: 'new', me: 'this', parent: 'super',
+    attempt: 'try', oops: 'catch', panic: 'throw', done: 'finally',
+    later: 'async', wait: 'await', remove: 'delete', kind: 'typeof', is: 'instanceof',
+    mine: 'private', everyone: 'public', family: 'protected', shared: 'static',
+    yes: 'true', no: 'false', empty: 'null', unknown: 'undefined'
+};
+export class CodeGenerator {
+    constructor() {
+        this.out = '';
+        this.level = 0;
+    }
+    line(s = '') { this.out += '  '.repeat(this.level) + s + '\n'; }
+    emit(s) { this.out += s; }
+    indent() { this.level++; }
+    dedent() { this.level--; }
+    generate(program) {
+        this.out = '';
+        this.level = 0;
+        this.line('// Generated by CodeScript v1.0.0');
+        this.line();
+        for (const stmt of program.body)
+            this.genStmt(stmt);
+        return this.out;
+    }
+    genStmt(stmt) {
+        switch (stmt.kind) {
+            case 'VariableDeclaration': {
+                if (stmt.keyword === 'keep')
+                    console.warn('Warning: "keep" is deprecated. Use "make" instead.');
+                const val = stmt.value ? ` = ${this.genExpr(stmt.value)}` : '';
+                this.line(`${KW[stmt.keyword]} ${stmt.name.name}${val};`);
+                break;
+            }
+            case 'FunctionDeclaration': {
+                const a = stmt.isAsync ? 'async ' : '';
+                const p = stmt.params.map(x => x.name).join(', ');
+                if (stmt.name.name === '') {
+                    this.emit(`${a}function(${p}){`);
+                    this.line();
+                    this.indent();
+                    this.genBlock(stmt.body);
+                    this.dedent();
+                    this.line('}');
+                    break;
+                }
+                this.line(`${a}function ${stmt.name.name}(${p}){`);
+                this.indent();
+                this.genBlock(stmt.body);
+                this.dedent();
+                this.line('}');
+                this.line();
+                break;
+            }
+            case 'ReturnStatement':
+                this.line(`return${stmt.value ? ' ' + this.genExpr(stmt.value) : ''};`);
+                break;
+            case 'IfStatement': {
+                this.line(`if(${this.genExpr(stmt.condition)}){`);
+                this.indent();
+                this.genBlock(stmt.consequent);
+                this.dedent();
+                if (stmt.alternate) {
+                    const inner = stmt.alternate.body;
+                    if (inner.length === 1 && inner[0].kind === 'IfStatement') {
+                        this.emit('}else ');
+                        this.genStmt(inner[0]);
+                        break;
+                    }
+                    this.line('}else{');
+                    this.indent();
+                    this.genBlock(stmt.alternate);
+                    this.dedent();
+                }
+                this.line('}');
+                break;
+            }
+            case 'SwitchStatement': {
+                this.line(`switch(${this.genExpr(stmt.discriminant)}){`);
+                this.indent();
+                for (const c of stmt.cases) {
+                    this.line(`case ${this.genExpr(c.test)}:`);
+                    this.indent();
+                    this.genBlock(c.body);
+                    this.line('break;');
+                    this.dedent();
+                }
+                if (stmt.defaultCase) {
+                    this.line('default:');
+                    this.indent();
+                    this.genBlock(stmt.defaultCase);
+                    this.dedent();
+                }
+                this.dedent();
+                this.line('}');
+                break;
+            }
+            case 'RepeatStatement': {
+                let init = '';
+                if (stmt.init?.kind === 'VariableDeclaration')
+                    init = `${KW[stmt.init.keyword]} ${stmt.init.name.name}${stmt.init.value ? ' = ' + this.genExpr(stmt.init.value) : ''}`;
+                else if (stmt.init?.kind === 'ExpressionStatement')
+                    init = this.genExpr(stmt.init.expression);
+                this.line(`for(${init}; ${stmt.condition ? this.genExpr(stmt.condition) : ''}; ${stmt.update ? this.genExpr(stmt.update) : ''}){`);
+                this.indent();
+                this.genBlock(stmt.body);
+                this.dedent();
+                this.line('}');
+                break;
+            }
+            case 'UntilStatement':
+                this.line(`while(${this.genExpr(stmt.condition)}){`);
+                this.indent();
+                this.genBlock(stmt.body);
+                this.dedent();
+                this.line('}');
+                break;
+            case 'BreakStatement':
+                this.line('break;');
+                break;
+            case 'ContinueStatement':
+                this.line('continue;');
+                break;
+            case 'ClassDeclaration': {
+                const ext = stmt.superClass ? ` extends ${stmt.superClass.name}` : '';
+                this.line(`class ${stmt.name.name}${ext}{`);
+                this.indent();
+                for (const m of stmt.body.members) {
+                    const p = m.params.map(x => x.name).join(', ');
+                    if (m.kind === 'ConstructorDeclaration') {
+                        this.line(`constructor(${p}){`);
+                        this.indent();
+                        this.genBlock(m.body);
+                        this.dedent();
+                        this.line('}');
+                    }
+                    else {
+                        this.line(`${m.isStatic ? 'static ' : ''}${m.isAsync ? 'async ' : ''}${m.name.name}(${p}){`);
+                        this.indent();
+                        this.genBlock(m.body);
+                        this.dedent();
+                        this.line('}');
+                    }
+                }
+                this.dedent();
+                this.line('}');
+                this.line();
+                break;
+            }
+            case 'ImportDeclaration': {
+                const src = stmt.source.replace('.code', '.js');
+                this.line(stmt.specifiers.length === 0 ? `import "${src}";` : `import { ${stmt.specifiers.map(s => s.name).join(', ')} } from "${src}";`);
+                break;
+            }
+            case 'ExportDeclaration':
+                this.line(`export { ${stmt.specifiers.map(s => s.name).join(', ')} };`);
+                break;
+            case 'TryStatement': {
+                this.line('try{');
+                this.indent();
+                this.genBlock(stmt.body);
+                this.dedent();
+                this.emit('}');
+                if (stmt.handler) {
+                    this.emit(`catch(${stmt.handler.param.name}){`);
+                    this.line();
+                    this.indent();
+                    this.genBlock(stmt.handler.body);
+                    this.dedent();
+                    this.emit('}');
+                }
+                if (stmt.finalizer) {
+                    this.emit('finally{');
+                    this.line();
+                    this.indent();
+                    this.genBlock(stmt.finalizer);
+                    this.dedent();
+                    this.emit('}');
+                }
+                this.line();
+                break;
+            }
+            case 'ThrowStatement':
+                this.line(`throw ${this.genExpr(stmt.value)};`);
+                break;
+            case 'ExpressionStatement':
+                this.line(`${this.genExpr(stmt.expression)};`);
+                break;
+        }
+    }
+    genBlock(block) { for (const s of block.body)
+        this.genStmt(s); }
+    genExpr(expr) {
+        switch (expr.kind) {
+            case 'Identifier': return KW[expr.name] ?? expr.name;
+            case 'Literal': return expr.value === null ? 'null' : expr.value === undefined ? 'undefined' : typeof expr.value === 'string' ? `"${expr.value}"` : String(expr.value);
+            case 'TemplateLiteral': return `\`${expr.raw}\``;
+            case 'BinaryExpression': return `${this.genExpr(expr.left)} ${expr.operator} ${this.genExpr(expr.right)}`;
+            case 'LogicalExpression': return `${this.genExpr(expr.left)} ${expr.operator} ${this.genExpr(expr.right)}`;
+            case 'UnaryExpression': {
+                if (expr.operator === 'post++')
+                    return `${this.genExpr(expr.operand)}++`;
+                if (expr.operator === 'post--')
+                    return `${this.genExpr(expr.operand)}--`;
+                return `${expr.operator} ${this.genExpr(expr.operand)}`;
+            }
+            case 'AssignmentExpression': return `${this.genExpr(expr.left)} ${expr.operator} ${this.genExpr(expr.right)}`;
+            case 'CallExpression': {
+                const callee = this.genExpr(expr.callee);
+                return `${KW[callee] ?? callee}(${expr.args.map(a => this.genExpr(a)).join(', ')})`;
+            }
+            case 'MemberExpression': return expr.computed ? `${this.genExpr(expr.object)}[${this.genExpr(expr.property)}]` : `${this.genExpr(expr.object)}.${this.genExpr(expr.property)}`;
+            case 'ArrayExpression': return `[${expr.elements.map(e => this.genExpr(e)).join(', ')}]`;
+            case 'ObjectExpression': return expr.properties.length === 0 ? '{}' : `{ ${expr.properties.map(p => `${p.key.name}: ${this.genExpr(p.value)}`).join(', ')} }`;
+            case 'NewExpression': return `new ${expr.callee.name}(${expr.args.map(a => this.genExpr(a)).join(', ')})`;
+            case 'FunctionExpression': {
+                const a = expr.isAsync ? 'async ' : '';
+                const p = expr.params.map(x => x.name).join(', ');
+                const sub = new CodeGenerator();
+                for (const s of expr.body.body)
+                    sub.genStmt(s);
+                return `${a}function(${p}){ ${sub.out.trim()} }`;
+            }
+        }
+    }
+}
+//# sourceMappingURL=compiler-core.js.map