mevento 2.0.6 → 3.0.0

package/fesm2020/mevento.mjs

@@ -1,2175 +0,0 @@
-function error(token, expected) {
-    const text = `Invalid token ${token.type}[${token.value}] at ${token.line}, ${token.col} ${expected ? `: expecting ${expected} token` : ''}\n`;
-    throw Error(text);
-}
-function isNum(value) {
-    return typeof value === 'number';
-}
-function isBoolean(value) {
-    return typeof value === 'boolean';
-}
-function isString(value) {
-    return typeof value === 'string';
-}
-function _boolValue(test) {
-    return (test === null ||
-        (isNum(test) && test === 0) ||
-        (isString(test) && test.length === 0) ||
-        (isBoolean(test) && !test)) ? false : true;
-}
-;
-function hashCode(str) {
-    let hash = 0;
-    let i = 0;
-    let chr;
-    if (str.length === 0)
-        return hash;
-    for (i = 0; i < str.length; i++) {
-        chr = str.charCodeAt(i);
-        hash = ((hash << 5) - hash) + chr;
-        hash |= 0; // Convert to 32bit integer
-    }
-    return hash;
-}
-;
-class TokenType {
-}
-TokenType.id = 0;
-TokenType.comma = 1;
-TokenType.semi = 2;
-TokenType.numberConst = 3;
-TokenType.stringConst = 4;
-TokenType.equal = 5;
-TokenType.lparen = 6;
-TokenType.rparen = 7;
-TokenType.eol = 8;
-TokenType.eof = 9;
-TokenType.lbrace = 10;
-TokenType.rbrace = 11;
-TokenType.lbracket = 12;
-TokenType.rbracket = 13;
-TokenType.great = 14;
-TokenType.greatEq = 15;
-TokenType.less = 16;
-TokenType.lessEq = 17;
-TokenType.eqeq = 18;
-TokenType.IF = 19;
-TokenType.ELSE = 20;
-TokenType.TRUE = 21;
-TokenType.FALSE = 22;
-TokenType.NULL = 23;
-TokenType.not = 24;
-TokenType.notEq = 25;
-TokenType.and = 26;
-TokenType.or = 27;
-TokenType.plus = 28;
-TokenType.minus = 29;
-TokenType.div = 30;
-TokenType.mult = 31;
-TokenType.mod = 32;
-TokenType.invalid = 33;
-TokenType.colon = 34;
-TokenType.WHILE_TILL = 35;
-TokenType.FOR_LOOP = 36;
-TokenType.up = 37;
-TokenType.down = 38;
-TokenType.with = 39;
-TokenType.in = 40;
-TokenType.TILL = 41;
-TokenType.BREAK = 42;
-TokenType.CONTINUE = 43;
-TokenType.nullity = 44;
-TokenType.RETURN = 45;
-class Token {
-    constructor(type, value, line = 1, col = 1) {
-        this.type = type;
-        this.value = value;
-        this.line = line;
-        this.col = col;
-    }
-    static from(type, value) {
-        return new Token(type, value);
-    }
-    toString() {
-        return `[${this.type.toString()}, ${this.value}]`;
-    }
-}
-class Chars {
-}
-Chars.equal = '='.charCodeAt(0);
-Chars.comma = ','.charCodeAt(0);
-Chars.semiColon = ';'.charCodeAt(0);
-Chars.lparen = '('.charCodeAt(0);
-Chars.rparen = ')'.charCodeAt(0);
-Chars.backslash = '\\'.charCodeAt(0);
-Chars.quote = '"'.charCodeAt(0);
-Chars.squote = "'".charCodeAt(0);
-Chars.plus = "+".charCodeAt(0);
-Chars.minus = "-".charCodeAt(0);
-Chars.star = "*".charCodeAt(0);
-Chars.slash = "/".charCodeAt(0);
-Chars.percent = "%".charCodeAt(0);
-Chars.lbrace = "{".charCodeAt(0);
-Chars.rbrace = "}".charCodeAt(0);
-Chars.lbracket = "[".charCodeAt(0);
-Chars.rbracket = "]".charCodeAt(0);
-Chars.not = "!".charCodeAt(0);
-Chars.great = ">".charCodeAt(0);
-Chars.less = "<".charCodeAt(0);
-Chars.and = "&".charCodeAt(0);
-Chars.pipe = "|".charCodeAt(0);
-Chars.colon = ":".charCodeAt(0);
-Chars.questionMark = "?".charCodeAt(0);
-Chars.shebang = "#".charCodeAt(0);
-class LexerDictionary {
-    constructor(lang, keywords) {
-        this.keywords = {};
-        this.keywords = { ...keywords };
-        this.lang = lang;
-    }
-}
-/**
- * Lexing => Parsing ===> AST ===> Walking
- */
-/**
- * Lexer
- */
-class Lexer {
-    constructor(source) {
-        this._position = 0;
-        this._line = 1;
-        this._col = 1;
-        this._currentChar = -1;
-        this._source = source;
-        this._currentChar = this._source[this._position].charCodeAt(0);
-        this._resolveLanguage();
-    }
-    get source() {
-        return this._source;
-    }
-    _resolveLanguage() {
-        let token = this.nextToken();
-        if (token.type === TokenType.less) {
-            // language setting
-            const idToken = this.nextToken();
-            if (idToken.type !== TokenType.id) {
-                error(token);
-            }
-            const lang = idToken.value.toString();
-            this._language = Lexer.languages.find((element) => element.lang === lang) ?? Lexer._defaultLanguage;
-            token = this.nextToken();
-            if (token.type !== TokenType.great) {
-                error(token);
-            }
-        }
-        else {
-            this._language = Lexer._defaultLanguage;
-            // reset reading
-            this._position = 0;
-            this._currentChar = this._source[this._position].charCodeAt(0);
-        }
-    }
-    _advance() {
-        this._position++;
-        if (this._position >= this._source.length) {
-            this._currentChar = -1;
-            return;
-        }
-        this._currentChar = this._source[this._position].charCodeAt(0);
-        this._col++;
-    }
-    _pick() {
-        if (this._position + 1 >= this._source.length) {
-            return -1;
-        }
-        return this._source[this._position + 1].charCodeAt(0);
-    }
-    _isId(code) {
-        if (code < 48) {
-            return code === 36;
-        }
-        if (code < 58) {
-            return true;
-        }
-        if (code < 65) {
-            return false;
-        }
-        if (code < 91) {
-            return true;
-        }
-        if (code < 97) {
-            return code === 95;
-        }
-        if (code < 123) {
-            return true;
-        }
-        return false;
-    }
-    _isIdStart(code) {
-        if (code < 65) {
-            return code === 36;
-        }
-        if (code < 91) {
-            return true;
-        }
-        if (code < 97) {
-            return code === 95;
-        }
-        if (code < 123) {
-            return true;
-        }
-        return false;
-    }
-    _id() {
-        let ret = "";
-        const lastC = this._col;
-        const lastP = this._position;
-        const line = this._line;
-        while (this._isId(this._currentChar)) {
-            ret += String.fromCharCode(this._currentChar);
-            this._advance();
-        }
-        const translatedId = this._language
-            ? (this._language.keywords[ret]) ?? ret
-            : ret;
-        return Lexer.RESERVED[translatedId] ?? new Token(TokenType.id, ret, line, lastC);
-    }
-    _isLineEnd(c) {
-        return c === 10 ||
-            c === 13 ||
-            ['\n', '\r', '\u2028', '\u2029'].includes(String.fromCharCode(c));
-    }
-    _isWhiteSpace(c) {
-        return [' ', '\t'].includes(String.fromCharCode(c));
-    }
-    _isDigit(c) {
-        // tslint:disable-next-line:no-bitwise
-        return c > 0 && (c ^ 0x30) <= 9;
-    }
-    _skipWhiteSpace() {
-        while (this._isWhiteSpace(this._currentChar) === true) {
-            this._advance();
-        }
-    }
-    _number() {
-        let ret = "";
-        const lastC = this._col;
-        const lastP = this._position;
-        const line = this._line;
-        const first = String.fromCharCode(this._currentChar);
-        this._advance();
-        const bc = String.fromCharCode(this._currentChar);
-        let base = 10;
-        if (first === '0' && ['b', 'B', 'x', 'X', 'o', 'O'].includes(bc)) {
-            // look ahead to see that the number is tagged
-            this._advance();
-            switch (bc.toLowerCase()) {
-                case 'b':
-                    base = 2;
-                    break;
-                case "o":
-                    base = 8;
-                    break;
-                case "x":
-                    base = 16;
-                    break;
-                default:
-                    base = 10;
-            }
-        }
-        else {
-            ret += first;
-            base = 10;
-        }
-        while (this._isDigit(this._currentChar) ||
-            (base === 16 &&
-                ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f']
-                    .includes(String.fromCharCode(this._currentChar)))) {
-            ret += String.fromCharCode(this._currentChar);
-            this._advance();
-        }
-        if (String.fromCharCode(this._currentChar) === '.' && this._isDigit(this._pick()) === true) {
-            if (base !== 10) {
-                error(new Token(TokenType.id, bc, line, lastP));
-            }
-            // floating number
-            ret += String.fromCharCode(this._currentChar);
-            this._advance();
-            while (this._isDigit(this._currentChar)) {
-                ret += String.fromCharCode(this._currentChar);
-                this._advance();
-            }
-            return new Token(TokenType.numberConst, parseFloat(ret), line, lastC);
-        }
-        return new Token(TokenType.numberConst, parseInt(ret, base), line, lastC);
-    }
-    _literalString(startChar) {
-        let ret = "";
-        let lastChar = -1;
-        const lastP = this._position;
-        const lastC = this._col;
-        const lastL = this._line;
-        while (this._currentChar !== -1) {
-            const next = String.fromCharCode(this._pick());
-            if (this._currentChar === Chars.backslash) {
-                // scape char
-                if ([
-                    startChar,
-                    '\\',
-                    '0',
-                    'a',
-                    'b',
-                    'e',
-                    'f',
-                    'n',
-                    'r',
-                    't',
-                    'u',
-                    'U',
-                    'v',
-                    'x'
-                ].includes(next)) {
-                    lastChar = this._currentChar;
-                    this._advance();
-                    continue;
-                }
-            }
-            if (this._currentChar === startChar && lastChar !== Chars.backslash) {
-                // end
-                break;
-            }
-            ret += String.fromCharCode(this._currentChar);
-            lastChar = this._currentChar;
-            this._advance();
-        }
-        return new Token(TokenType.stringConst, ret, lastL, lastC);
-    }
-    _skipLineComment() {
-        while (!this._isLineEnd(this._currentChar) === true && this._currentChar != -1) {
-            this._advance();
-        }
-    }
-    _skipComment() {
-        while (this._currentChar !== -1) {
-            if (this._currentChar === Chars.star && this._pick() === Chars.shebang) {
-                // end of block comment
-                this._advance();
-                this._advance();
-                break;
-            }
-            this._advance();
-        }
-    }
-    // f=SUBMIT_FORM(xxx);
-    // r = CALL_API(API_ID, f);
-    // DISPLAY("MSG #r")
-    nextToken() {
-        const lastL = this._line;
-        const lastC = this._col;
-        const lastP = this._position;
-        while (this._currentChar !== -1) {
-            if (this._isLineEnd(this._currentChar)) {
-                this._line++;
-                this._col = 1;
-                this._advance();
-                return new Token(TokenType.eol, "\n", lastL, lastC);
-            }
-            if (this._isWhiteSpace(this._currentChar)) {
-                this._skipWhiteSpace();
-                continue;
-            }
-            if (this._currentChar == Chars.shebang) {
-                this._advance();
-                if (this._currentChar === Chars.star) {
-                    // mutli block comment
-                    this._advance();
-                    this._skipComment();
-                }
-                else {
-                    this._skipLineComment();
-                }
-                continue;
-            }
-            if (this._isDigit(this._currentChar)) {
-                return this._number();
-            }
-            if (this._isIdStart(this._currentChar)) {
-                return this._id();
-            }
-            if (this._currentChar === Chars.equal) {
-                this._advance();
-                if (this._currentChar === Chars.equal) {
-                    this._advance();
-                    return new Token(TokenType.eqeq, "==", lastL, lastC);
-                }
-                return new Token(TokenType.equal, "=", lastL, lastC);
-            }
-            if (this._currentChar === Chars.great) {
-                this._advance();
-                if (this._currentChar === Chars.equal) {
-                    this._advance();
-                    return new Token(TokenType.greatEq, ">=", lastL, lastC);
-                }
-                return new Token(TokenType.great, ">", lastL, lastC);
-            }
-            if (this._currentChar === Chars.less) {
-                this._advance();
-                if (this._currentChar === Chars.equal) {
-                    this._advance();
-                    return new Token(TokenType.lessEq, "<=", lastL, lastC);
-                }
-                return new Token(TokenType.less, "<", lastL, lastC);
-            }
-            if (this._currentChar === Chars.semiColon) {
-                this._advance();
-                return new Token(TokenType.semi, ";", lastL, lastC);
-            }
-            if (this._currentChar === Chars.lparen) {
-                this._advance();
-                return new Token(TokenType.lparen, "(", lastL, lastC);
-            }
-            if (this._currentChar === Chars.rparen) {
-                this._advance();
-                return new Token(TokenType.rparen, ")", lastL, lastC);
-            }
-            if (this._currentChar === Chars.comma) {
-                this._advance();
-                return new Token(TokenType.comma, ",", lastL, lastC);
-            }
-            if (this._currentChar === Chars.lbrace) {
-                this._advance();
-                return new Token(TokenType.lbrace, "{", lastL, lastC);
-            }
-            if (this._currentChar === Chars.rbrace) {
-                this._advance();
-                return new Token(TokenType.rbrace, "}", lastL, lastC);
-            }
-            if (this._currentChar === Chars.lbracket) {
-                this._advance();
-                return new Token(TokenType.lbracket, "[", lastL, lastC);
-            }
-            if (this._currentChar === Chars.rbracket) {
-                this._advance();
-                return new Token(TokenType.rbracket, "]", lastL, lastC);
-            }
-            if (this._currentChar === Chars.plus) {
-                this._advance();
-                return new Token(TokenType.plus, "+", lastL, lastC);
-            }
-            if (this._currentChar === Chars.minus) {
-                this._advance();
-                return new Token(TokenType.minus, "-", lastL, lastC);
-            }
-            if (this._currentChar === Chars.slash) {
-                this._advance();
-                return new Token(TokenType.div, "/", lastL, lastC);
-            }
-            if (this._currentChar === Chars.star) {
-                this._advance();
-                return new Token(TokenType.mult, "*", lastL, lastC);
-            }
-            if (this._currentChar === Chars.percent) {
-                this._advance();
-                return new Token(TokenType.mod, "%", lastL, lastC);
-            }
-            if (this._currentChar === Chars.colon) {
-                this._advance();
-                return new Token(TokenType.colon, ":", lastL, lastC);
-            }
-            if (this._currentChar === Chars.not) {
-                this._advance();
-                if (this._currentChar === Chars.equal) {
-                    this._advance();
-                    return new Token(TokenType.notEq, "!=", lastL, lastC);
-                }
-                return new Token(TokenType.not, "!", lastL, lastC);
-            }
-            if (this._currentChar === Chars.and && this._pick() === Chars.and) {
-                this._advance();
-                this._advance();
-                return new Token(TokenType.and, "&&", lastL, lastC);
-            }
-            if (this._currentChar === Chars.pipe && this._pick() === Chars.pipe) {
-                this._advance();
-                this._advance();
-                return new Token(TokenType.or, '||', lastL, lastC);
-            }
-            if (this._currentChar === Chars.questionMark && this._pick() === Chars.questionMark) {
-                this._advance();
-                this._advance();
-                return new Token(TokenType.nullity, '??', lastL, lastC);
-            }
-            if (this._currentChar === Chars.quote || this._currentChar === Chars.squote) {
-                const startChar = this._currentChar;
-                this._advance();
-                const t = this._literalString(startChar);
-                this._advance();
-                return t;
-            }
-            return new Token(TokenType.invalid, String.fromCharCode(this._currentChar), lastL, lastC);
-        }
-        return new Token(TokenType.eof, "", lastL, lastC);
-    }
-}
-Lexer._defaultLanguage = new LexerDictionary("en", {
-    "if": "if",
-    "else": "else",
-    "true": "true",
-    "false": "false",
-    "null": "null",
-    "while": "while",
-    "for": "for",
-    "with": "with",
-    "up": "up",
-    "down": "down",
-    "till": "till",
-    "in": "in",
-    "break": "break",
-    "continue": "continue",
-    "return": "return",
-});
-Lexer.languages = [
-    Lexer._defaultLanguage,
-    new LexerDictionary("fr", {
-        "si": "if",
-        "sinon": "else",
-        "vrai": "true",
-        "faux": "false",
-        "nul": "null",
-        "tanque": "while",
-        "pour": "for",
-        "avec": "with",
-        "mont": "up",
-        "desc": "down",
-        "jusqua": "till",
-        "dans": "in",
-        "couper": "break",
-        "continuer": "continue",
-        "returner": "return",
-    }),
-    new LexerDictionary("bm", {
-        "nii": "if",
-        "note": "else",
-        "tien": "true",
-        "galon": "false",
-        "gansan": "null",
-        "foo": "while",
-        "seginka": "for",
-        "niin": "with",
-        "kay": "up",
-        "kaj": "down",
-        "kata": "till",
-        "kono": "in",
-        "tike": "break",
-        "ipan": "continue",
-        "segin": "return",
-    }),
-];
-Lexer.RESERVED = {
-    "if": Token.from(TokenType.IF, "if"),
-    "else": Token.from(TokenType.ELSE, "else"),
-    "true": Token.from(TokenType.TRUE, true),
-    "false": Token.from(TokenType.FALSE, false),
-    "null": Token.from(TokenType.NULL, null),
-    "for": Token.from(TokenType.FOR_LOOP, "for"),
-    "while": Token.from(TokenType.WHILE_TILL, "while"),
-    "with": Token.from(TokenType.with, "with"),
-    "up": Token.from(TokenType.up, "up"),
-    "down": Token.from(TokenType.down, "down"),
-    "till": Token.from(TokenType.TILL, "till"),
-    "in": Token.from(TokenType.in, "in"),
-    "break": Token.from(TokenType.BREAK, "break"),
-    "continue": Token.from(TokenType.CONTINUE, "continue"),
-    "return": Token.from(TokenType.RETURN, "return"),
-};
-/**
- * Parser
- */
-class AST {
-    constructor(line, col) {
-        this.line = line;
-        this.col = col;
-    }
-    dump() {
-        return this.toString();
-    }
-}
-class RootAST extends AST {
-    constructor(body, name, source) {
-        super(1, 1);
-        this.body = body;
-        this.name = name;
-        this.source = source;
-    }
-    dump() {
-        let builder = `Module ${this.name} Start {`;
-        for (const it of this.body) {
-            builder += `${it.dump()}\n`;
-        }
-        builder += "}";
-        return builder;
-    }
-}
-class BlockStatementAST extends AST {
-    constructor(body, token) {
-        super(token.line, token.col);
-        this.body = body;
-    }
-    toString() {
-        return `{\n${this.body.map((e) => e.toString()).join("\n")}}`;
-    }
-}
-class IdentifierAST extends AST {
-    constructor(token) {
-        super(token.line, token.col);
-        this.value = token.value.toString();
-    }
-    toString() {
-        return this.value;
-    }
-}
-class LiteralAST extends AST {
-    constructor(token, raw) {
-        super(token.line, token.col);
-        this.value = token.value;
-        this.raw = raw;
-    }
-    toString() {
-        return this.value.toString();
-    }
-}
-class AssignmentExpressionAST extends AST {
-    constructor(identifier, init) {
-        super(identifier.line, identifier.col);
-        this.identifier = identifier;
-        this.init = init;
-    }
-    toString() {
-        return `${this.identifier} = ${this.init}`;
-    }
-}
-class ExpressionStatementAST extends AST {
-    constructor(expression) {
-        super(expression.line, expression.col);
-        this.expression = expression;
-    }
-    toString() {
-        return this.expression.toString();
-    }
-}
-class CallExpressionAST extends AST {
-    constructor(callee, ags) {
-        super(callee.line, callee.col);
-        this.callee = callee;
-        this.arguments = ags;
-    }
-    toString() {
-        return `${this.callee.toString()}(...${this.arguments.length})`;
-    }
-}
-class BinaryExpressionAST extends AST {
-    constructor(left, operation, right) {
-        super(left.line, left.col);
-        this.left = left;
-        this.operation = operation;
-        this.right = right;
-    }
-    toString() {
-        return `${this.left} ${this.operation} ${this.right}`;
-    }
-}
-class UnaryExpressionAST extends AST {
-    constructor(operation, argument) {
-        super(operation.line, operation.col);
-        this.operation = operation, this.argument = argument;
-    }
-    toString() {
-        return `${this.operation} ${this.argument}`;
-    }
-}
-class IfStatementAST extends AST {
-    constructor(test, consequent, alternate) {
-        super(test.line, test.col);
-        this.test = test;
-        this.consequent = consequent;
-        this.alternate = alternate;
-    }
-    toString() {
-        return `if ${this.test} ${this.consequent} ${this.alternate ? `else ${this.alternate} ` : ''}`;
-    }
-}
-class LogicalExpressionAST extends AST {
-    constructor(left, operator, right) {
-        super(left.line, left.col);
-        this.left = left;
-        this.operator = operator;
-        this.right = right;
-    }
-    toString() {
-        return `${this.left} ${this.operator.value} ${this.right}`;
-    }
-}
-class IndexAccessorAST extends AST {
-    constructor(owner, key, computed = false) {
-        super(owner.line, owner.col);
-        this.computed = false;
-        this.owner = owner;
-        this.key = key;
-        this.computed = computed;
-    }
-    toString() {
-        return `${this.owner}[${this.key}]`;
-    }
-}
-class ObjectExpression extends AST {
-    constructor(props, startToken, endToken) {
-        super(startToken?.line, startToken?.col);
-        this.properties = props;
-    }
-    toString() {
-        return "{...}";
-    }
-}
-class ArrayExpression extends AST {
-    constructor(props, start, end) {
-        super(start?.line, start?.col);
-        this.elements = props;
-    }
-    toString() {
-        return "[...]";
-    }
-}
-class ObjectProperty extends AST {
-    constructor(key, value) {
-        super(key.line, key.col);
-        this.value = value;
-        this.key = key;
-    }
-}
-class WhileLoopStatement extends AST {
-    constructor(test, body, startToken, endToken, retain = false) {
-        super(startToken?.line, startToken?.col);
-        this.retain = false;
-        this.test = test;
-        this.body = body;
-        this.retain = retain;
-    }
-}
-class ForLoopStatement extends AST {
-    constructor(init, test, update, direction, body, startToken, endToken, retain = false) {
-        super(startToken?.line, startToken?.col);
-        this.init = init;
-        this.test = test;
-        this.update = update;
-        this.direction = direction;
-        this.body = body;
-        this.retain = retain;
-    }
-}
-class ForOfStatement extends AST {
-    constructor(identifier, collection, body, startToken, endToken, retain = false) {
-        super(startToken?.line, startToken?.col);
-        this.identifier = identifier;
-        this.collection = collection;
-        this.body = body;
-        this.retain = retain;
-    }
-}
-class TupleExpression extends AST {
-    constructor(first, second) {
-        super(first.line, first.col);
-        this.first = first;
-        this.second = second;
-    }
-}
-class BreakAST extends AST {
-    constructor(line, col) {
-        super(line, col);
-    }
-}
-class ReturnAST extends AST {
-    constructor(value, line, col) {
-        super(line, col);
-        this.value = value;
-    }
-}
-class ContinueAST extends AST {
-    constructor(line, col) {
-        super(line, col);
-    }
-}
-class Parser {
-    constructor(lexer) {
-        this.currentToken = lexer.nextToken();
-        this.lexer = lexer;
-    }
-    _eat(type) {
-        if (this.currentToken?.type === type) {
-            this.currentToken = this.lexer.nextToken();
-        }
-        else {
-            error(this.currentToken, type);
-        }
-    }
-    _eatEOL() {
-        while (this.currentToken?.type === TokenType.eol) {
-            this._eat(TokenType.eol);
-        }
-    }
-    _eatSemiOrEOL() {
-        while (this.currentToken?.type === TokenType.eol ||
-            this.currentToken?.type === TokenType.semi) {
-            this._eat(this.currentToken.type);
-        }
-    }
-    _eatSemi() {
-        while (this.currentToken?.type === TokenType.semi) {
-            this._eat(TokenType.semi);
-        }
-    }
-    _variable() {
-        const node = new IdentifierAST(this.currentToken);
-        this._eat(TokenType.id);
-        return node;
-    }
-    _return() {
-        const token = this.currentToken;
-        let value = undefined;
-        if (!this._expect(TokenType.eol) && !this._expect(TokenType.semi)) {
-            value = this._expression();
-        }
-        return new ReturnAST(value, token?.line, token?.col);
-    }
-    _factor() {
-        const token = this.currentToken;
-        switch (token.type) {
-            case TokenType.plus:
-            case TokenType.minus:
-            case TokenType.not:
-                this._eat(this.currentToken.type);
-                return new UnaryExpressionAST(token, this._term());
-            case TokenType.numberConst:
-                this._eat(TokenType.numberConst);
-                return new LiteralAST(token, token.value.toString());
-            case TokenType.stringConst:
-                this._eat(TokenType.stringConst);
-                return new LiteralAST(token, token.value.toString());
-            case TokenType.lparen:
-                this._eat(TokenType.lparen);
-                const node = this._expression();
-                this._eat(TokenType.rparen);
-                return node;
-            case TokenType.TRUE:
-            case TokenType.FALSE:
-                this._eat(this.currentToken.type);
-                return new LiteralAST(token, token.value.toString());
-            case TokenType.NULL:
-                this._eat(TokenType.NULL);
-                return new LiteralAST(token, "null");
-            case TokenType.lbracket:
-                // literal array expression
-                return this._arrayExpression();
-            case TokenType.lbrace:
-                return this._objectExpression();
-            case TokenType.IF:
-                return this._ifStatement();
-            default:
-                return this._variable();
-        }
-    }
-    _term() {
-        let node = this._factor();
-        node = this._tryParsingFunctionCall(node);
-        node = this._tryParsingMemberExpression(node);
-        return node;
-    }
-    _expression() {
-        let node = this._term();
-        node = this._tryBinaryExpression(0, node);
-        while ([TokenType.and, TokenType.or, TokenType.nullity].includes(this.currentToken.type)) {
-            const token = this.currentToken;
-            this._eat(token.type);
-            node = new LogicalExpressionAST(node, token, this._expression());
-        }
-        if (this._expect(TokenType.equal)) {
-            if (node instanceof IdentifierAST || node instanceof IndexAccessorAST) {
-                const token = this.currentToken;
-                this._eat(TokenType.equal);
-                node = new AssignmentExpressionAST(node, this._expression());
-            }
-            else {
-                throw new Error("Unexpected token");
-            }
-        }
-        return node;
-    }
-    _objectProperty() {
-        let key;
-        switch (this.currentToken?.type) {
-            case TokenType.stringConst:
-                {
-                    key = new LiteralAST(this.currentToken, this.currentToken.value);
-                    this._eat(TokenType.stringConst);
-                    break;
-                }
-            case TokenType.lbracket:
-                {
-                    this._eat(TokenType.lbracket);
-                    var expr = this._expression();
-                    this._eat(TokenType.rbracket);
-                    key = expr;
-                    break;
-                }
-            case TokenType.id:
-                {
-                    const id = this._variable();
-                    key = new LiteralAST(new Token(TokenType.id, id.value, id.line, id.col), id.value);
-                    break;
-                }
-            default:
-                throw `Unexpected token ${this.currentToken}`;
-        }
-        this._eat(TokenType.colon);
-        var value = this._expression();
-        return new ObjectProperty(key, value);
-    }
-    _property() {
-        return this._objectProperty();
-    }
-    _objectProperties() {
-        const properties = [];
-        if (this.currentToken?.type != TokenType.rbrace) {
-            this._eatEOL();
-            properties.push(this._property());
-            this._eatEOL();
-        }
-        while (this.currentToken?.type === TokenType.comma) {
-            this._eat(TokenType.comma);
-            this._eatEOL();
-            if (this._expect(TokenType.rbrace)) {
-                break;
-            }
-            properties.push(this._property());
-            this._eatEOL();
-        }
-        return properties;
-    }
-    _objectExpression(braceToken) {
-        var token = braceToken ?? this.currentToken;
-        if (!braceToken)
-            this._eat(TokenType.lbrace);
-        var properties = this._objectProperties();
-        this._eat(TokenType.rbrace);
-        return new ObjectExpression(properties, token, this.currentToken);
-    }
-    _arrayExpression() {
-        this._eat(TokenType.lbracket);
-        const elements = this._expect(TokenType.rbracket) ? [] : this._expressionsList();
-        this._eat(TokenType.rbracket);
-        var startNode = elements.length !== 0 ? elements[0] : undefined;
-        var lastNode = elements.length !== 0 ? elements[elements.length - 1] : undefined;
-        return new ArrayExpression(elements, startNode, lastNode);
-    }
-    _tryParsingMemberExpression(n) {
-        let node = n;
-        while (this.currentToken.type === TokenType.lbracket) {
-            this._eat(TokenType.lbracket);
-            const key = this._expression();
-            node = new IndexAccessorAST(node, key);
-            this._eat(TokenType.rbracket);
-        }
-        return node;
-    }
-    _tryBinaryExpression(prec, left) {
-        let node = left;
-        while (true) {
-            const currentPrec = Parser._binopPrecdences[this.currentToken.type] || -1;
-            if (currentPrec < prec)
-                return node;
-            const operator = this.currentToken;
-            this._eat(operator.type);
-            let right = this._term();
-            const nextPrec = Parser._binopPrecdences[this.currentToken.type] || -1;
-            if (currentPrec < nextPrec) {
-                const tmp = this._tryBinaryExpression(currentPrec + 1, right);
-                if (tmp === node)
-                    return tmp;
-                right = tmp;
-            }
-            node = new BinaryExpressionAST(node, operator, right);
-        }
-    }
-    _expressionsList() {
-        this._eatEOL();
-        // if (expect(Lexer.TokenType.RPAREN)) return emptyList()
-        let expr = this._expression();
-        this._eatEOL();
-        const result = [expr];
-        while (this.currentToken?.type === TokenType.comma) {
-            this._eat(TokenType.comma);
-            this._eatEOL();
-            if (this._expect(TokenType.rbracket)) {
-                break;
-            }
-            expr = this._expression();
-            result.push(expr);
-            this._eatEOL();
-        }
-        return result;
-    }
-    _callExpression(node) {
-        this._eat(TokenType.lparen);
-        let args = [];
-        if (!this._expect(TokenType.rparen)) {
-            args = this._expressionsList();
-        }
-        this._eat(TokenType.rparen);
-        if (!(node instanceof IdentifierAST)) {
-            error(this.currentToken);
-        }
-        return new CallExpressionAST(node, args);
-    }
-    _tryParsingFunctionCall(n) {
-        let node = n;
-        while (this.currentToken.type === TokenType.lparen) {
-            // probable function call
-            node = this._callExpression(node);
-        }
-        return node;
-    }
-    _statementExpression() {
-        const node = this._expression();
-        if (![TokenType.semi, TokenType.eol, TokenType.eof]
-            .includes(this.currentToken.type)) {
-            error(this.currentToken);
-        }
-        return node;
-    }
-    _blockStatement(ignoreFirstBrace = false) {
-        if (!ignoreFirstBrace)
-            this._eat(TokenType.lbrace);
-        this._eatEOL();
-        if (this._expect(TokenType.rbrace)) {
-            this._eat(TokenType.rbrace);
-            return new BlockStatementAST([], this.currentToken);
-        }
-        // const body = _statements();
-        const body = [this._statement()];
-        while (true) {
-            this._eatSemiOrEOL();
-            if (this.currentToken.type === TokenType.rbrace || this.currentToken.type === TokenType.eof) {
-                // _eat(this.currentToken!.type);
-                break;
-            }
-            body.push(this._statement());
-            if (this._expect(TokenType.rbrace))
-                break;
-            if (this.currentToken.type !== TokenType.eol &&
-                this.currentToken.type !== TokenType.semi &&
-                this.currentToken.type !== TokenType.eof) {
-                error(this.currentToken);
-            }
-        }
-        this._eat(TokenType.rbrace);
-        if (this.currentToken?.type === TokenType.rbrace) {
-            // endBlock
-            this._eat(TokenType.rbrace);
-        }
-        return new BlockStatementAST(body, this.currentToken);
-    }
-    _ifStatement() {
-        this._eat(TokenType.IF);
-        const withPar = this.currentToken.type === TokenType.lparen;
-        if (withPar) {
-            this._eat(TokenType.lparen);
-        }
-        const test = this._expression();
-        if (withPar) {
-            this._eat(TokenType.rparen);
-        }
-        let consequent;
-        if (this.currentToken.type === TokenType.lbrace) {
-            consequent = this._blockStatement();
-        }
-        else {
-            consequent = this._expression();
-        }
-        // this._eatSemiOrEOL();
-        let alternate;
-        if (this.currentToken.type === TokenType.ELSE) {
-            this._eat(TokenType.ELSE);
-            switch (this.currentToken.type) {
-                case TokenType.IF:
-                    alternate = this._ifStatement();
-                    break;
-                case TokenType.lbrace:
-                    alternate = this._blockStatement();
-                    break;
-                default:
-                    alternate = this._expression();
-            }
-        }
-        return new IfStatementAST(test, consequent, alternate);
-    }
-    _whileLoop() {
-        const token = this.currentToken;
-        this._eat(TokenType.WHILE_TILL);
-        const test = this._expression();
-        const body = this.currentToken.type === TokenType.lbrace ? this._blockStatement() : this._expression();
-        return new WhileLoopStatement(test, body, token, this.currentToken);
-    }
-    _forOfIdentifier() {
-        switch (this.currentToken.type) {
-            case TokenType.lparen: {
-                // probable tuple
-                this._eat(TokenType.lparen);
-                const first = this._variable();
-                this._eat(TokenType.comma);
-                const second = this._variable();
-                this._eat(TokenType.rparen);
-                return new TupleExpression(first, second);
-            }
-            // TokenType.LBRACE -> objectPattern()
-            // TokenType.LBRACKET -> arrayPattern()
-            default:
-                return this._variable();
-        }
-    }
-    /**
-     * # ForLoopStatement with step
-     * (seginka|for) a=0 (foo|to) 10 (kay|kaj) niin 2 { # for a = 0; a<10; a+=2
-     *
-     * }
-     * (seginka|for) mali kono a
-     */
-    _forLoop() {
-        const startToken = this.currentToken;
-        this._eat(TokenType.FOR_LOOP);
-        let forOf = [TokenType.lparen].includes(this.currentToken.type);
-        let node;
-        if (forOf) {
-            node = this._forOfIdentifier();
-        }
-        else {
-            const expr = this._expression();
-            if (!(expr instanceof AssignmentExpressionAST)) {
-                forOf = true;
-            }
-            node = expr;
-        }
-        if (!forOf && node instanceof AssignmentExpressionAST) {
-            // normal for
-            this._eat(TokenType.TILL);
-            const test = this._expression();
-            let direction;
-            if (this.currentToken.type === TokenType.up || this.currentToken.type === TokenType.down) {
-                const t = this.currentToken;
-                this._eat(t.type);
-                direction = t;
-            }
-            else {
-                direction = new Token(TokenType.up, "up");
-            }
-            let update;
-            if (this._expect(TokenType.with)) {
-                this._eat(TokenType.with);
-                const expr = this._expression();
-                update = expr;
-            }
-            else {
-                update = new LiteralAST(new Token(TokenType.numberConst, 1, this.currentToken.line, this.currentToken.col), "1");
-            }
-            const body = (this.currentToken.type === TokenType.lbrace) ? this._blockStatement() : this._expression();
-            node = new ForLoopStatement(node, test, update, direction, body, startToken, this.currentToken);
-        }
-        else if (forOf) {
-            this._eat(TokenType.in);
-            const collection = this._expression();
-            const body = (this.currentToken.type === TokenType.lbrace) ? this._blockStatement() : this._expression();
-            node = new ForOfStatement(node, collection, body, startToken, this.currentToken);
-        }
-        else {
-            error(this.currentToken);
-        }
-        return node;
-    }
-    _statement() {
-        switch (this.currentToken.type) {
-            case TokenType.BREAK:
-                this._eat(TokenType.BREAK);
-                return new BreakAST(this.currentToken?.line, this.currentToken?.col);
-            case TokenType.CONTINUE:
-                this._eat(TokenType.CONTINUE);
-                return new ContinueAST(this.currentToken?.line, this.currentToken?.col);
-            case TokenType.RETURN:
-                this._eat(TokenType.RETURN);
-                return this._return();
-            case TokenType.semi:
-                this._eatSemi();
-                return this._statement();
-            case TokenType.eol:
-                this._eatEOL();
-                return this._statement();
-            // case TokenType.IF:
-            //     return this._ifStatement();
-            case TokenType.WHILE_TILL:
-                return this._whileLoop();
-            case TokenType.FOR_LOOP:
-                return this._forLoop();
-            default:
-                return this._statementExpression();
-        }
-    }
-    _expect(type) {
-        return this.currentToken?.type === type;
-    }
-    _definition() {
-        this._eatSemiOrEOL();
-        if (this._expect(TokenType.eof)) {
-            return [];
-        }
-        const results = [this._statement()];
-        while (true) {
-            this._eatSemiOrEOL();
-            if (this.currentToken.type === TokenType.eof) {
-                this._eat(TokenType.eof);
-                break;
-            }
-            if (this.currentToken.type === TokenType.lbrace) {
-                results.push(this._blockStatement());
-            }
-            else {
-                results.push(this._statement());
-            }
-            // if (this.currentToken!.type !== TokenType.eol &&
-            //     this.currentToken!.type !== TokenType.semi &&
-            //     this.currentToken!.type !== TokenType.eof) {
-            //     error(this.currentToken!);
-            // }
-        }
-        return results;
-    }
-    _root() {
-        const source = this.lexer.source;
-        const name = "<module>";
-        const list = this._definition();
-        return new RootAST(list, name, source);
-    }
-    parse() {
-        return this._root();
-    }
-}
-Parser._binopPrecdences = {
-    [TokenType.eqeq]: 10,
-    [TokenType.notEq]: 10,
-    [TokenType.great]: 10,
-    [TokenType.greatEq]: 10,
-    [TokenType.less]: 10,
-    [TokenType.lessEq]: 10,
-    [TokenType.plus]: 20,
-    [TokenType.minus]: 20,
-    [TokenType.mult]: 40,
-    [TokenType.div]: 40,
-    [TokenType.mod]: 40,
-};
-class LoopControl {
-}
-class BreakBranch extends LoopControl {
-}
-class ContinueBranch extends LoopControl {
-}
-class ReturnBranch {
-    constructor(value) {
-        this.value = value;
-    }
-}
-;
-// AST Wallker
-class ANodeVisitor {
-    constructor() {
-        this._nodesVisitors = {};
-    }
-    registerVisitor(type, visitor) {
-        const methodName = `visit${type.name}`;
-        this._nodesVisitors[methodName] = visitor;
-    }
-}
-class NodeVisitor extends ANodeVisitor {
-    constructor() {
-        super();
-        this.registerVisitor(RootAST, this.visitRootAST);
-        this.registerVisitor(BlockStatementAST, this.visitBlockStatementAST);
-        this.registerVisitor(IdentifierAST, this.visitIdentifierAST);
-        this.registerVisitor(LiteralAST, this.visitLiteralAST);
-        this.registerVisitor(AssignmentExpressionAST, this.visitAssignmentExpressionAST);
-        this.registerVisitor(ExpressionStatementAST, this.visitExpressionStatementAST);
-        this.registerVisitor(CallExpressionAST, this.visitCallExpressionAST);
-        this.registerVisitor(BinaryExpressionAST, this.visitBinaryExpressionAST);
-        this.registerVisitor(UnaryExpressionAST, this.visitUnaryExpressionAST);
-        this.registerVisitor(IfStatementAST, this.visitIfStatementAST);
-        this.registerVisitor(LogicalExpressionAST, this.visitLogicalExpressionAST);
-        this.registerVisitor(IndexAccessorAST, this.visitIndexAccessorAST);
-        this.registerVisitor(ObjectProperty, this.visitObjectProperty);
-        this.registerVisitor(ObjectExpression, this.visitObjectExpression);
-        this.registerVisitor(ArrayExpression, this.visitArrayExpression);
-        this.registerVisitor(WhileLoopStatement, this.visitWhileLoopStatement);
-        this.registerVisitor(ForLoopStatement, this.visitForLoopStatement);
-        this.registerVisitor(ForOfStatement, this.visitForOfStatement);
-        this.registerVisitor(BreakAST, this.visitBreakAST);
-        this.registerVisitor(ContinueAST, this.visitContinueAST);
-        this.registerVisitor(ReturnAST, this.visitReturnAST);
-    }
-    visit(node) {
-        try {
-            const methodName = `visit${node.constructor.name}`;
-            // const fn = Object.getPrototypeOf(this)[methodName];
-            const fn = this._nodesVisitors[methodName];
-            return fn?.call(this, node) ?? null;
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    assignProperty(owner, property, value) {
-        if (Array.isArray(owner)) {
-            owner[property] = value;
-        }
-        else if (typeof owner === 'object') {
-            owner[property] = value;
-        }
-        else { }
-    }
-}
-class MEventScope {
-    constructor(name, memory, parent) {
-        this.memory = {};
-        this.name = name;
-        this.memory = memory;
-        this.parent = parent;
-    }
-    resolve(key) {
-        return Object.keys(this.memory).includes(key) ? this.memory[key] : (this.parent?.resolve(key) ?? null);
-    }
-    change(key, value, declare = true) {
-        if (Object.keys(this.memory).includes(key)) {
-            // change here
-            this.memory[key] = value;
-            return true;
-        }
-        if (this.parent && this.parent.change(key, value, false)) {
-            return true;
-        }
-        if (!declare) {
-            return false;
-        }
-        this.memory[key] = value;
-        return true;
-    }
-}
-class MEvento extends NodeVisitor {
-    constructor() {
-        super();
-        this.rootScope = new MEventScope("Program", {});
-        this.currentScope = this.rootScope;
-        this.debug = false;
-        this._functionsRegistry = {};
-        this._functionsRegistry = { ...MEvento._globalFunctionsRegistry };
-    }
-    resolve(name) {
-        return this.currentScope?.resolve(name) ?? null;
-    }
-    changeVariable(name, value) {
-        if (this.currentScope?.change(name, value)) {
-            return value;
-        }
-        else
-            return null;
-    }
-    pushScope(name) {
-        const scope = new MEventScope(name, {}, this.currentScope);
-        this.currentScope = scope;
-    }
-    popScope() {
-        this.currentScope = this.currentScope?.parent;
-    }
-    log(message) {
-        if (this.debug) {
-            console.log(message);
-        }
-    }
-    visitRootAST(node) {
-        const list = node.body;
-        let last;
-        for (const n of list) {
-            last = this.visit(n);
-            if (last instanceof ReturnBranch) {
-                return last.value ?? null;
-            }
-        }
-        return last ?? null;
-    }
-    visitBlockStatementAST(node) {
-        const list = node.body;
-        let last;
-        this.pushScope("Block");
-        for (const n of list) {
-            last = this.visit(n);
-            if (last instanceof LoopControl) {
-                break;
-            }
-            if (last instanceof ReturnBranch) {
-                break;
-            }
-        }
-        this.popScope();
-        return last ?? null;
-    }
-    visitIdentifierAST(node) {
-        const id = node.value;
-        return this?.resolve(id) ?? null;
-    }
-    visitLiteralAST(node) {
-        const value = node.value;
-        return value;
-    }
-    visitAssignmentExpressionAST(node) {
-        const id = node.identifier;
-        const init = node.init;
-        let value = null;
-        if (id instanceof IndexAccessorAST) {
-            var target = this.visit(id.owner);
-            value = this.visit(node.init);
-            var property = this.visit(id.key);
-            this.assignProperty(target, property, value);
-        }
-        else if (id instanceof IdentifierAST) {
-            value = this.visit(init);
-            this.changeVariable(id.value, value);
-        }
-        return value;
-    }
-    visitExpressionStatementAST(node) {
-        const expr = node.expression;
-        return this.visit(expr);
-    }
-    visitCallExpressionAST(node) {
-        const callee = node.callee;
-        const args = node.arguments;
-        const calleeName = callee.value;
-        const fn = this.resolveFunction(calleeName);
-        const argValues = args.map((e) => this.visit(e));
-        // print("argValues::", argValues)
-        return fn?.(argValues, this);
-    }
-    visitBinaryExpressionAST(node) {
-        const left = node.left;
-        const right = node.right;
-        const op = node.operation;
-        const lValue = this.visit(left);
-        const rValue = this.visit(right);
-        switch (op.type) {
-            case TokenType.plus:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue + rValue;
-                }
-                return `${lValue}${rValue}`;
-            case TokenType.minus:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue - rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.mult:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue * rValue;
-                }
-                if (isString(lValue) && isNum(rValue)) {
-                    return lValue.repeat(rValue);
-                }
-                if (isNum(lValue) && isString(rValue)) {
-                    return rValue.repeat(lValue);
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.div:
-                if (isNum(lValue) && isNum(rValue)) {
-                    if (rValue === 0) {
-                        throw new Error("Invalid division by 0");
-                    }
-                    return lValue / rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.mod:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue % rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.great:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue > rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.greatEq:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue >= rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.less:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue < rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.lessEq:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue <= rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.eqeq:
-                return lValue === rValue;
-            case TokenType.notEq:
-                return lValue !== rValue;
-            default:
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-        }
-    }
-    visitUnaryExpressionAST(node) {
-        const arg = node.argument;
-        const op = node.operation;
-        const argValue = this.visit(arg);
-        if (op.type === TokenType.not) {
-            return _boolValue(argValue) === false;
-        }
-        if (!isNum(argValue)) {
-            throw new Error(`Operation ${op.value} not allowed no num value`);
-        }
-        if (op.type === TokenType.plus) {
-            return argValue;
-        }
-        else if (op.type === TokenType.minus) {
-            return -argValue;
-        }
-        throw new Error(`Operation ${op.value} not allowed no num value`);
-    }
-    visitIfStatementAST(node) {
-        const testNode = node.test;
-        const test = this.visit(testNode);
-        const testBoolValue = _boolValue(test);
-        if (testBoolValue) {
-            return this.visit(node.consequent);
-        }
-        if (node.alternate) {
-            return this.visit(node.alternate);
-        }
-        return null;
-    }
-    visitLogicalExpressionAST(node) {
-        const leftNode = node.left;
-        let test = this.visit(leftNode);
-        if (node.operator.type === TokenType.nullity) {
-            if (test != null) {
-                return test;
-            }
-            return this.visit(node.right);
-        }
-        const testBoolValue = _boolValue(test);
-        if (node.operator.type === TokenType.and) {
-            if (!testBoolValue) {
-                return false;
-            }
-            return _boolValue(this.visit(node.right));
-        }
-        if (node.operator.type === TokenType.or) {
-            if (testBoolValue) {
-                return true;
-            }
-            return _boolValue(this.visit(node.right));
-        }
-        return null;
-    }
-    visitIndexAccessorAST(node) {
-        const ownerNode = node.owner;
-        const owner = this.visit(ownerNode);
-        if (owner === null || owner === undefined) {
-            return null;
-        }
-        if (typeof owner === 'object') {
-            const key = this.visit(node.key);
-            return owner[key] ?? null;
-        }
-        else if (Array.isArray(owner)) {
-            const key = this.visit(node.key);
-            return isNum(key) && owner.length < key && key >= 0 ? owner[key] ?? null : null;
-        }
-        return null;
-    }
-    visitObjectProperty(node) { }
-    visitObjectExpression(ast) {
-        const instance = {};
-        const node = ast;
-        for (const it of node.properties) {
-            if (it instanceof ObjectProperty) {
-                let key = this.visit(it.key);
-                key = isString(key) ? key : key.toString();
-                instance[key] = this.visit(it.value);
-            }
-        }
-        return instance;
-    }
-    visitArrayExpression(ast) {
-        const node = ast;
-        const args = this.resolveArguments(node.elements);
-        return args;
-    }
-    visitBreakAST(node) {
-        return new BreakBranch();
-    }
-    visitWhileLoopStatement(node) {
-        this.log(`WhileLoopStatement ${node.test} ${node.body}`);
-        const retainer = node.retain ? [] : undefined;
-        while (_boolValue(this.visit(node.test))) {
-            const ret = this.visit(node.body);
-            if (ret instanceof BreakBranch) {
-                break;
-            }
-            if (ret instanceof ContinueBranch) {
-                continue;
-            }
-            if (ret instanceof ReturnBranch) {
-                this.popScope();
-                return ret;
-            }
-            retainer?.push(ret);
-        }
-        return retainer ?? null;
-    }
-    visitForLoopStatement(node) {
-        const retainer = node.retain ? [] : undefined;
-        const loopIdentifier = node.init.identifier;
-        if (!(loopIdentifier instanceof IdentifierAST))
-            throw new Error("Unexpected identifer found");
-        this.pushScope("ForLoopStatement");
-        const initialValue = this.visit(node.init.init);
-        this.changeVariable(loopIdentifier.value, initialValue);
-        retainer?.push(initialValue);
-        const test = () => {
-            const ret = this.visit(node.test);
-            if (isNum(ret)) {
-                const tmp = this.resolve(loopIdentifier.value);
-                return node.direction.type === TokenType.up ? ret >= tmp : ret <= tmp;
-            }
-            return _boolValue(ret);
-        };
-        const update = () => {
-            const updateValue = this.visit(node.update);
-            if (isNum(updateValue)) {
-                // auto handle
-                const tmp = this.resolve(loopIdentifier.value);
-                if (!isNum(tmp))
-                    throw Error("Cant update value");
-                this.changeVariable(loopIdentifier.value, node.direction.type === TokenType.up ? tmp + updateValue : tmp - updateValue);
-            }
-            else {
-                throw Error("Update value cant be non number");
-            }
-        };
-        while (test()) {
-            const ret = this.visit(node.body);
-            if (ret instanceof BreakBranch) {
-                break;
-            }
-            if (ret instanceof ContinueBranch) {
-                update();
-                continue;
-            }
-            if (ret instanceof ReturnBranch) {
-                this.popScope();
-                return ret;
-            }
-            retainer?.push(ret);
-            // update
-            update();
-        }
-        this.popScope();
-        return retainer ?? null;
-    }
-    visitForOfStatement(node) {
-        const collection = this.visit(node.collection);
-        if (!Array.isArray(collection)) {
-            throw Error("Can iterate non array object");
-        }
-        const retainer = node.retain ? [] : undefined;
-        this.pushScope("ForOfStatement");
-        for (const it of collection) {
-            this._declareForIdentifier(node.identifier, it);
-            const ret = this.visit(node.body);
-            if (ret instanceof BreakBranch) {
-                break;
-            }
-            if (ret instanceof ContinueBranch) {
-                continue;
-            }
-            if (ret instanceof ReturnBranch) {
-                this.popScope();
-                return ret;
-            }
-            retainer?.push(ret);
-        }
-        this.popScope();
-        return retainer ?? null;
-    }
-    visitContinueAST(node) {
-        return new ContinueBranch();
-    }
-    visitReturnAST(node) {
-        return new ReturnBranch(node.value != null ? this.visit(node.value) : null);
-    }
-    _declareForIdentifier(node, value) {
-        if (node instanceof TupleExpression) {
-            if (!Array.isArray(value)) {
-                throw Error("Unable to make a tuple from non Array element");
-            }
-            this.changeVariable(node.first.value, value[0]);
-            this.changeVariable(node.second.value, value[1]);
-        }
-        this.changeVariable(node.value, value);
-    }
-    resolveArguments(args) {
-        return args.map((it) => {
-            return this.visit(it);
-        });
-    }
-    setFunctionResolver(resolver) {
-        this._functionResolver = resolver;
-    }
-    resolveFunction(name) {
-        return this._functionsRegistry[name] ?? this._functionResolver?.(name);
-    }
-    registerFunction(id, fn) {
-        this._functionsRegistry[id] = fn;
-    }
-    unregisterFunction(id) {
-        delete this._functionsRegistry[id];
-    }
-    execute(source, cache = true, input) {
-        const module = MEvento.compile(source, cache);
-        if (input) {
-            Object.keys(input).forEach(k => this.changeVariable(k, input[k]));
-        }
-        return this.visit(module);
-    }
-    static compile(source, cache = false) {
-        const hash = hashCode(source);
-        if (cache && this._cache.has(hash)) {
-            return this._cache.get(hash);
-        }
-        const lexer = new Lexer(source);
-        const parser = new Parser(lexer);
-        const module = parser.parse();
-        if (cache)
-            this._cache.set(hash, module);
-        return module;
-    }
-    static register(id, fn) {
-        MEvento._globalFunctionsRegistry[id] = fn;
-    }
-    static unregister(id) {
-        delete MEvento._globalFunctionsRegistry[id];
-    }
-    static run(source, cache = false, input) {
-        const mevento = new MEvento();
-        const module = MEvento.compile(source, cache);
-        if (input) {
-            Object.keys(input).forEach(k => mevento.changeVariable(k, input[k]));
-        }
-        return mevento.visit(module);
-    }
-    static newInstance() {
-        // const lexer = Lexer(source);
-        // const parser = Parser(lexer);
-        // const module = parser.parse();
-        return new MEvento();
-    }
-    clone() {
-        var ret = new MEvento();
-        ret._functionsRegistry = { ...this._functionsRegistry };
-        ret.rootScope.memory = { ...this.rootScope.memory };
-        return ret;
-    }
-    newAsyncInstance() {
-        const asyncIns = MEventoAsync.newInstance();
-        asyncIns.rootScope.memory = this.rootScope.memory;
-        /// ????
-        asyncIns._functionsRegistry = this._functionsRegistry;
-        return asyncIns;
-    }
-    ;
-}
-MEvento._globalFunctionsRegistry = {};
-MEvento._cache = new Map();
-class MEventoAsync extends MEvento {
-    constructor() {
-        super();
-    }
-    async visitRootAST(node) {
-        const list = node.body;
-        let last;
-        for (const n of list) {
-            last = await this.visit(n);
-            if (last instanceof ReturnBranch) {
-                return last.value ?? null;
-            }
-        }
-        return last ?? null;
-    }
-    async visitBlockStatementAST(node) {
-        const list = node.body;
-        let last;
-        this.pushScope("Block");
-        for (const n of list) {
-            last = await this.visit(n);
-            if (last instanceof LoopControl) {
-                break;
-            }
-            if (last instanceof ReturnBranch) {
-                break;
-            }
-        }
-        this.popScope();
-        return last;
-    }
-    async visitIdentifierAST(node) {
-        const id = node.value;
-        return this.resolve(id);
-    }
-    async visitLiteralAST(node) {
-        const value = node.value;
-        return value;
-    }
-    async visitAssignmentExpressionAST(node) {
-        const id = node.identifier;
-        const init = node.init;
-        let value = null;
-        if (id instanceof IndexAccessorAST) {
-            var target = await this.visit(id.owner);
-            value = await this.visit(node.init);
-            var property = await this.visit(id.key);
-            this.assignProperty(target, property, value);
-        }
-        else if (id instanceof IdentifierAST) {
-            value = await this.visit(init);
-            this.changeVariable(id.value, value);
-        }
-        return value;
-    }
-    async visitExpressionStatementAST(node) {
-        const expr = node.expression;
-        return await this.visit(expr);
-    }
-    async visitCallExpressionAST(node) {
-        const callee = node.callee;
-        const args = node.arguments;
-        const calleeName = callee.value;
-        const fn = this._functionsRegistry[calleeName];
-        const argValues = await Promise.all(args.map((e) => this.visit(e)));
-        // print("argValues::", argValues)
-        return await fn?.(argValues, this);
-    }
-    async visitBinaryExpressionAST(node) {
-        const left = node.left;
-        const right = node.right;
-        const op = node.operation;
-        const lValue = await this.visit(left);
-        const rValue = await this.visit(right);
-        switch (op.type) {
-            case TokenType.plus:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue + rValue;
-                }
-                return `${lValue}${rValue}`;
-            case TokenType.minus:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue - rValue;
-                }
-                if (isString(lValue) && isNum(rValue)) {
-                    return lValue.repeat(rValue);
-                }
-                if (isNum(lValue) && isString(rValue)) {
-                    return rValue.repeat(lValue);
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.mult:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue * rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.div:
-                if (isNum(lValue) && isNum(rValue)) {
-                    if (rValue === 0) {
-                        throw new Error("Invalid division by 0");
-                    }
-                    return lValue / rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.mod:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue % rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.great:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue > rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.greatEq:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue >= rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.less:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue < rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.lessEq:
-                if (isNum(lValue) && isNum(rValue)) {
-                    return lValue <= rValue;
-                }
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-            case TokenType.eqeq:
-                return lValue === rValue;
-            case TokenType.notEq:
-                return lValue !== rValue;
-            default:
-                throw new Error(`Operation ${op.value} not allowed no num value`);
-        }
-    }
-    async visitUnaryExpressionAST(node) {
-        const arg = node.argument;
-        const op = node.operation;
-        const argValue = await this.visit(arg);
-        if (op.type === TokenType.not) {
-            return _boolValue(argValue) === false;
-        }
-        if (!isNum(argValue)) {
-            throw new Error(`Operation ${op.value} not allowed no num value`);
-        }
-        if (op.type === TokenType.plus) {
-            return argValue;
-        }
-        else if (op.type === TokenType.minus) {
-            return -argValue;
-        }
-        throw new Error(`Operation ${op.value} not allowed no num value`);
-    }
-    async visitIfStatementAST(node) {
-        const testNode = node.test;
-        const test = await this.visit(testNode);
-        const testBoolValue = _boolValue(test);
-        if (testBoolValue) {
-            return await this.visit(node.consequent);
-        }
-        if (node.alternate) {
-            return await this.visit(node.alternate);
-        }
-        return null;
-    }
-    async visitLogicalExpressionAST(node) {
-        const leftNode = node.left;
-        let test = await this.visit(leftNode);
-        if (node.operator.type === TokenType.nullity) {
-            if (test != null) {
-                return test;
-            }
-            return await this.visit(node.right);
-        }
-        const testBoolValue = _boolValue(test);
-        if (node.operator.type === TokenType.and) {
-            if (!testBoolValue) {
-                return false;
-            }
-            return _boolValue(await this.visit(node.right));
-        }
-        if (node.operator.type === TokenType.or) {
-            if (testBoolValue) {
-                return true;
-            }
-            return _boolValue(await this.visit(node.right));
-        }
-        return false;
-    }
-    async visitIndexAccessorAST(node) {
-        const ownerNode = node.owner;
-        const owner = await this.visit(ownerNode);
-        if (owner === null || owner === undefined) {
-            return null;
-        }
-        if (typeof owner === 'object') {
-            const key = await this.visit(node.key);
-            return owner[key] ?? null;
-        }
-        else if (Array.isArray(owner)) {
-            const key = await this.visit(node.key);
-            return isNum(key) && owner.length < key && key >= 0 ? owner[key] ?? null : null;
-        }
-        return null;
-    }
-    async visitObjectProperty(node) { }
-    async visitObjectExpression(ast) {
-        const instance = {};
-        const node = ast;
-        for (const it of node.properties) {
-            if (it instanceof ObjectProperty) {
-                let key = await this.visit(it.key);
-                key = isString(key) ? key : key.toString();
-                instance[key] = await this.visit(it.value);
-            }
-        }
-        return instance;
-    }
-    async visitArrayExpression(ast) {
-        const node = ast;
-        const args = await this.resolveArgumentsAsync(node.elements);
-        return args;
-    }
-    async visitWhileLoopStatement(node) {
-        this.log(`WhileLoopStatement ${node.test} ${node.body}`);
-        const retainer = node.retain ? [] : undefined;
-        while (_boolValue(await this.visit(node.test))) {
-            const ret = await this.visit(node.body);
-            if (ret instanceof BreakBranch) {
-                break;
-            }
-            if (ret instanceof ContinueBranch) {
-                continue;
-            }
-            if (ret instanceof ReturnBranch) {
-                this.popScope();
-                return ret;
-            }
-            retainer?.push(ret);
-        }
-        return retainer;
-    }
-    async visitForLoopStatement(node) {
-        const retainer = node.retain ? [] : undefined;
-        const loopIdentifier = node.init.identifier;
-        if (!(loopIdentifier instanceof IdentifierAST))
-            throw new Error("Unexpected identifer found");
-        this.pushScope("ForLoopStatement");
-        const initialValue = await this.visit(node.init.init);
-        this.changeVariable(loopIdentifier.value, initialValue);
-        retainer?.push(initialValue);
-        const test = async () => {
-            const ret = await this.visit(node.test);
-            if (isNum(ret)) {
-                const tmp = this.resolve(loopIdentifier.value);
-                return node.direction.type === TokenType.up ? ret >= tmp : ret <= tmp;
-            }
-            return _boolValue(ret);
-        };
-        const update = async () => {
-            const updateValue = await this.visit(node.update);
-            if (isNum(updateValue)) {
-                // auto handle
-                const tmp = this.resolve(loopIdentifier.value);
-                if (!isNum(tmp))
-                    throw Error("Cant update value");
-                this.changeVariable(loopIdentifier.value, node.direction.type === TokenType.up ? tmp + updateValue : tmp - updateValue);
-            }
-            else {
-                throw Error("Update value cant be non number");
-            }
-        };
-        while (await test()) {
-            const ret = await this.visit(node.body);
-            if (ret instanceof BreakBranch) {
-                break;
-            }
-            if (ret instanceof ContinueBranch) {
-                await update();
-                continue;
-            }
-            if (ret instanceof ReturnBranch) {
-                this.popScope();
-                return ret;
-            }
-            retainer?.push(ret);
-            // update
-            await update();
-        }
-        this.popScope();
-        return retainer ?? null;
-    }
-    async visitForOfStatement(node) {
-        const collection = await this.visit(node.collection);
-        if (!Array.isArray(collection)) {
-            throw Error("Can iterate non array object");
-        }
-        const retainer = node.retain ? [] : undefined;
-        this.pushScope("ForOfStatement");
-        for (const it of collection) {
-            this._declareForIdentifier(node.identifier, it);
-            const ret = await this.visit(node.body);
-            if (ret instanceof BreakBranch) {
-                break;
-            }
-            if (ret instanceof ContinueBranch) {
-                continue;
-            }
-            if (ret instanceof ReturnBranch) {
-                this.popScope();
-                return ret;
-            }
-            retainer?.push(ret);
-        }
-        this.popScope();
-        return retainer;
-    }
-    async visitReturnAST(node) {
-        return new ReturnBranch(node.value != null ? await this.visit(node.value) : null);
-    }
-    async resolveArgumentsAsync(args) {
-        return await Promise.all(args.map(async (it) => {
-            return await this.visit(it);
-        }));
-    }
-    registerFunction(id, fn) {
-        this._functionsRegistry[id] = fn;
-    }
-    unregisterFunction(id) {
-        delete this._functionsRegistry[id];
-    }
-    async execute(source, cache = true, input) {
-        const module = MEvento.compile(source, cache);
-        if (input) {
-            Object.keys(input).forEach(k => this.changeVariable(k, input[k]));
-        }
-        return await this.visit(module);
-    }
-    static async run(source, cache = false, input) {
-        const mevento = new MEventoAsync();
-        const module = MEvento.compile(source, cache);
-        if (input) {
-            Object.keys(input).forEach(k => mevento.changeVariable(k, input[k]));
-        }
-        return await mevento.visit(module);
-    }
-    static newInstance() {
-        return new MEventoAsync();
-    }
-    clone() {
-        var ret = new MEventoAsync();
-        ret._functionsRegistry = { ...this._functionsRegistry };
-        ret.rootScope.memory = { ...this.rootScope.memory };
-        return ret;
-    }
-}
-
-/*
- * Public API Surface of mevento
- */
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { AST, ArrayExpression, AssignmentExpressionAST, BinaryExpressionAST, BlockStatementAST, BreakAST, BreakBranch, CallExpressionAST, ContinueAST, ContinueBranch, ExpressionStatementAST, ForLoopStatement, ForOfStatement, IdentifierAST, IfStatementAST, IndexAccessorAST, LexerDictionary, LiteralAST, LogicalExpressionAST, LoopControl, MEventScope, MEvento, MEventoAsync, NodeVisitor, ObjectExpression, ObjectProperty, ReturnAST, ReturnBranch, RootAST, Token, TokenType, TupleExpression, UnaryExpressionAST, WhileLoopStatement };
-//# sourceMappingURL=mevento.mjs.map