mevento 1.0.0

package/esm2020/lib/mevento.mjs

@@ -0,0 +1,1560 @@
+function error(token) {
+    const text = `Invalid token ${token.type}[${token.value}] at ${token.line}, ${token.col}\n`;
+    throw (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));
+}
+;
+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);
+        // tslint:disable-next-line:no-bitwise
+        hash = ((hash << 5) - hash) + chr;
+        // tslint:disable-next-line:no-bitwise
+        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;
+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);
+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 >= this._source.length) {
+            return -1;
+        }
+        return this._source[this._position].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 String.fromCharCode(c).trim() === "" &&
+            String.fromCharCode(c).length > 0;
+    }
+    _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);
+    }
+    // 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._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.and, '||', 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",
+});
+Lexer.languages = [
+    Lexer._defaultLanguage,
+    new LexerDictionary("fr", {
+        "si": "if",
+        "sinon": "else",
+        "vrai": "else",
+        "faux": "false",
+        "nul": "null",
+    }),
+    new LexerDictionary("bm", {
+        "nii": "if",
+        "note": "else",
+        "tien": "true",
+        "galon": "false",
+        "gansan": "null",
+    }),
+];
+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),
+};
+/**
+ * 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 !== null ? `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 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);
+        }
+    }
+    _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;
+    }
+    _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._factor());
+            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();
+            default:
+                return this._variable();
+        }
+    }
+    _term() {
+        let node = this._factor();
+        node = this._tryParsingMemberExpression(node);
+        node = this._tryParsingFunctionCall(node);
+        return node;
+    }
+    _expression() {
+        let node = this._term();
+        node = this._tryBinaryExpression(0, node);
+        while ([TokenType.and, TokenType.or].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) {
+            properties.push(this._property());
+        }
+        while (this.currentToken?.type == TokenType.comma) {
+            this._eat(TokenType.comma);
+            properties.push(this._property());
+        }
+        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();
+        const result = [expr];
+        while (this.currentToken?.type === TokenType.comma) {
+            this._eat(TokenType.comma);
+            expr = this._expression();
+            result.push(expr);
+        }
+        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 (this.currentToken.type === TokenType.eol ||
+            this.currentToken.type === TokenType.semi) {
+            this._eatSemiOrEOL();
+            if (this.currentToken.type === TokenType.rbrace || this.currentToken.type === TokenType.eof) {
+                // _eat(this.currentToken!.type);
+                break;
+            }
+            body.push(this._statement());
+            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);
+    }
+    _statement() {
+        switch (this.currentToken.type) {
+            case TokenType.semi:
+                this._eatSemi();
+                return this._statement();
+            case TokenType.eol:
+                this._eatEOL();
+                return this._statement();
+            case TokenType.IF:
+                return this._ifStatement();
+            default:
+                return this._statementExpression();
+        }
+    }
+    _expect(type) {
+        return this.currentToken?.type === type;
+    }
+    _statements() {
+        this._eatEOL();
+        if (this._expect(TokenType.eof)) {
+            return [];
+        }
+        const results = [this._statement()];
+        while ((this.currentToken.type === TokenType.eol ||
+            this.currentToken.type === TokenType.semi)) {
+            this._eatSemiOrEOL();
+            if (this.currentToken.type === TokenType.eof) {
+                this._eat(TokenType.eof);
+                break;
+            }
+            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._statements();
+        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,
+};
+// AST Wallker
+class ANodeVisitor {
+    constructor() {
+        this._nodesVisitors = {};
+    }
+    registerVisitor(type, visitor) {
+        const methodName = `visit${type.name}`;
+        // console.log('Reg::::::', methodName, type);
+        this._nodesVisitors[methodName] = visitor;
+    }
+}
+class AsyncNodeVisitor extends ANodeVisitor {
+    async visit(node) {
+        const methodName = `visit${node.constructor.name}`;
+        // const fn = Object.getPrototypeOf(this)[methodName];
+        const fn = this._nodesVisitors[methodName];
+        return await fn?.call(this, node);
+    }
+}
+class NodeVisitor extends ANodeVisitor {
+    visit(node) {
+        const methodName = `visit${node.constructor.name}`;
+        // const fn = Object.getPrototypeOf(this)[methodName];
+        const fn = this._nodesVisitors[methodName];
+        return fn?.call(this, node);
+    }
+}
+export class MEvento extends NodeVisitor {
+    constructor() {
+        super();
+        this._memory = {};
+        this._functionsRegistry = {};
+        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._functionsRegistry = { ...MEvento._globalFunctionsRegistry };
+    }
+    visitRootAST(node) {
+        const list = node.body;
+        let last;
+        for (const n of list) {
+            last = this.visit(n);
+        }
+        return last;
+    }
+    visitBlockStatementAST(node) {
+        const list = node.body;
+        let last;
+        for (const n of list) {
+            last = this.visit(n);
+        }
+        return last;
+    }
+    visitIdentifierAST(node) {
+        const id = node.value;
+        return this._memory[id];
+    }
+    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._memory[id.value] = value;
+        }
+        return value;
+    }
+    assignProperty(owner, property, value) {
+        if (Array.isArray(owner)) {
+            owner[property] = value;
+        }
+        else if (typeof owner === 'object') {
+            owner[property] = value;
+        }
+        else { }
+    }
+    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._functionsRegistry[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;
+                }
+                if (isString(lValue) && isNum(rValue)) {
+                    return lValue * rValue;
+                }
+                if (isNum(lValue) && isString(rValue)) {
+                    return rValue * 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`);
+        }
+    }
+    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 !== null) {
+            return this.visit(node.alternate);
+        }
+        return null;
+    }
+    visitLogicalExpressionAST(node) {
+        const leftNode = node.left;
+        const test = this.visit(leftNode);
+        const testBoolValue = _boolValue(test);
+        if (node.operator.type === TokenType.and) {
+            return testBoolValue && _boolValue(this.visit(node.right));
+        }
+        if (node.operator.type === TokenType.or) {
+            return testBoolValue || _boolValue(this.visit(node.right));
+        }
+        return false;
+    }
+    visitIndexAccessorAST(node) {
+        const ownerNode = node.owner;
+        const owner = this.visit(ownerNode);
+        if (typeof owner === 'object') {
+            const key = this.visit(node.key);
+            return owner[key];
+        }
+        else if (Array.isArray(owner)) {
+            const key = this.visit(node.key);
+            return isNum(key) && owner.length < key && key >= 0 ? owner[key] : 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;
+    }
+    resolveArguments(args) {
+        return args.map((it) => {
+            return this.visit(it);
+        });
+    }
+    registerFunction(id, fn) {
+        this._functionsRegistry[id] = fn;
+    }
+    unregisterFunction(id) {
+        delete this._functionsRegistry[id];
+    }
+    execute(source, cache = true) {
+        const module = MEvento.compile(source, cache);
+        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) {
+        const mevento = new MEvento();
+        const module = MEvento.compile(source, cache);
+        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._memory = { ...this._memory };
+        return ret;
+    }
+    newAsyncInstance() {
+        const asyncIns = MEventoAsync.newInstance();
+        asyncIns._memory = this._memory;
+        /// ????
+        asyncIns._functionsRegistry = this._functionsRegistry;
+        return asyncIns;
+    }
+    ;
+}
+MEvento._globalFunctionsRegistry = {};
+MEvento._cache = new Map();
+export 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);
+        }
+        return last;
+    }
+    async visitBlockStatementAST(node) {
+        const list = node.body;
+        let last;
+        for (const n of list) {
+            last = await this.visit(n);
+        }
+        return last;
+    }
+    async visitIdentifierAST(node) {
+        const id = node.value;
+        return this._memory[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._memory[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 * rValue;
+                }
+                if (isNum(lValue) && isString(rValue)) {
+                    return rValue * 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 (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 !== null) {
+            return await this.visit(node.alternate);
+        }
+        return null;
+    }
+    async visitLogicalExpressionAST(node) {
+        const leftNode = node.left;
+        const test = await this.visit(leftNode);
+        const testBoolValue = _boolValue(test);
+        if (node.operator.type === TokenType.and) {
+            return testBoolValue && _boolValue(await this.visit(node.right));
+        }
+        if (node.operator.type === TokenType.or) {
+            return testBoolValue || _boolValue(await this.visit(node.right));
+        }
+        return false;
+    }
+    async visitIndexAccessorAST(node) {
+        const ownerNode = node.owner;
+        const owner = await this.visit(ownerNode);
+        if (typeof owner === 'object') {
+            const key = await this.visit(node.key);
+            return owner[key];
+        }
+        else if (Array.isArray(owner)) {
+            const key = await this.visit(node.key);
+            return isNum(key) && owner.length < key && key >= 0 ? owner[key] : 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 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) {
+        const module = MEvento.compile(source, cache);
+        return await this.visit(module);
+    }
+    static async run(source, cache = false) {
+        const mevento = new MEventoAsync();
+        const module = MEvento.compile(source, cache);
+        return await mevento.visit(module);
+    }
+    static newInstance() {
+        // const lexer = Lexer(source);
+        // const parser = Parser(lexer);
+        // const module = parser.parse();
+        return new MEventoAsync();
+    }
+    clone() {
+        var ret = new MEventoAsync();
+        ret._functionsRegistry = { ...this._functionsRegistry };
+        ret._memory = { ...this._memory };
+        return ret;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mevento.js","sourceRoot":"","sources":["../../../../projects/mevento/src/lib/mevento.ts"],"names":[],"mappings":"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","sourcesContent":["import { Type } from \"@angular/core\";\n\nfunction error(token: Token) {\n    const text =\n        `Invalid token ${token.type}[${token.value}] at ${token.line}, ${token.col}\\n`;\n    throw (text);\n}\nfunction isNum(value: any) {\n    return typeof value === 'number';\n}\nfunction isBoolean(value: any) {\n    return typeof value === 'boolean';\n}\nfunction isString(value: any) {\n    return typeof value === 'string';\n}\nfunction _boolValue(test: any): boolean {\n    return test !== null &&\n        ((isNum(test) && test !== 0) ||\n            (isString(test) && test.length > 0) ||\n            (isBoolean(test) && test));\n};\n\nfunction hashCode(str: string) {\n    let hash = 0;\n    let i = 0;\n    let chr;\n    if (str.length === 0) return hash;\n    for (i = 0; i < str.length; i++) {\n        chr = str.charCodeAt(i);\n        // tslint:disable-next-line:no-bitwise\n        hash = ((hash << 5) - hash) + chr;\n        // tslint:disable-next-line:no-bitwise\n        hash |= 0; // Convert to 32bit integer\n    }\n    return hash;\n};\nclass TokenType {\n    static id = 0;\n    static comma = 1;\n    static semi = 2;\n    static numberConst = 3;\n    static stringConst = 4;\n    static equal = 5;\n    static lparen = 6\n    static rparen = 7;\n    static eol = 8;\n    static eof = 9;\n    static lbrace = 10;\n    static rbrace = 11;\n    static lbracket = 12;\n    static rbracket = 13;\n    static great = 14;\n    static greatEq = 15;\n    static less = 16;\n    static lessEq = 17;\n    static eqeq = 18;\n    static IF = 19;\n    static ELSE = 20;\n    static TRUE = 21;\n    static FALSE = 22;\n    static NULL = 23;\n    static not = 24;\n    static notEq = 25;\n    static and = 26;\n    static or = 27;\n    static plus = 28;\n    static minus = 29;\n    static div = 30;\n    static mult = 31;\n    static mod = 32;\n    static invalid = 33;\n    static colon = 34;\n}\n\nclass Token {\n    type: number;\n    value: any;\n    line?: number;\n    col?: number;\n    constructor(type: number, value: any, line: number = 1, col: number = 1) {\n        this.type = type;\n        this.value = value;\n        this.line = line;\n        this.col = col;\n    }\n    static from(type: number, value: any) {\n        return new Token(type, value);\n    }\n\n    toString(): string {\n        return `[${this.type.toString()}, ${this.value}]`;\n    }\n}\n\nclass Chars {\n    static equal = '='.charCodeAt(0);\n    static comma = ','.charCodeAt(0);\n    static semiColon = ';'.charCodeAt(0);\n    static lparen = '('.charCodeAt(0);\n    static rparen = ')'.charCodeAt(0);\n    static backslash = '\\\\'.charCodeAt(0);\n    static quote = '\"'.charCodeAt(0);\n    static squote = \"'\".charCodeAt(0);\n    static plus = \"+\".charCodeAt(0);\n    static minus = \"-\".charCodeAt(0);\n    static star = \"*\".charCodeAt(0);\n    static slash = \"/\".charCodeAt(0);\n    static percent = \"%\".charCodeAt(0);\n    static lbrace = \"{\".charCodeAt(0);\n    static rbrace = \"}\".charCodeAt(0);\n    static lbracket = \"[\".charCodeAt(0);\n    static rbracket = \"]\".charCodeAt(0);\n    static not = \"!\".charCodeAt(0);\n    static great = \">\".charCodeAt(0);\n    static less = \"<\".charCodeAt(0);\n    static and = \"&\".charCodeAt(0);\n    static pipe = \"|\".charCodeAt(0);\n    static colon = \":\".charCodeAt(0);\n}\n\nclass LexerDictionary {\n    lang: string;\n    keywords: { [key: string]: string } = {};\n    constructor(lang: string, keywords: { [key: string]: string }) {\n        this.keywords = { ...keywords };\n        this.lang = lang;\n    }\n}\n\n/**\n * Lexing => Parsing ===> AST ===> Walking\n */\n/**\n * Lexer\n */\nclass Lexer {\n    static _defaultLanguage = new LexerDictionary(\"en\", {\n        \"if\": \"if\",\n        \"else\": \"else\",\n        \"true\": \"true\",\n        \"false\": \"false\",\n        \"null\": \"null\",\n    });\n    static languages: LexerDictionary[] = [\n        Lexer._defaultLanguage,\n        new LexerDictionary(\"fr\", {\n            \"si\": \"if\",\n            \"sinon\": \"else\",\n            \"vrai\": \"else\",\n            \"faux\": \"false\",\n            \"nul\": \"null\",\n        }),\n        new LexerDictionary(\"bm\", {\n            \"nii\": \"if\",\n            \"note\": \"else\",\n            \"tien\": \"true\",\n            \"galon\": \"false\",\n            \"gansan\": \"null\",\n        }),\n    ];\n    static RESERVED: { [key: string]: Token } = {\n        \"if\": Token.from(TokenType.IF, \"if\"),\n        \"else\": Token.from(TokenType.ELSE, \"else\"),\n        \"true\": Token.from(TokenType.TRUE, true),\n        \"false\": Token.from(TokenType.FALSE, false),\n        \"null\": Token.from(TokenType.NULL, null),\n    };\n    _language?: LexerDictionary;\n    _source!: string;\n    _position = 0;\n    _line = 1;\n    _col = 1;\n    _currentChar = -1;\n    get source() {\n        return this._source;\n    }\n    constructor(source: string) {\n        this._source = source;\n        this._currentChar = this._source[this._position].charCodeAt(0);\n        this._resolveLanguage();\n    }\n    private _resolveLanguage() {\n        let token = this.nextToken();\n        if (token.type === TokenType.less) {\n            // language setting\n            const idToken = this.nextToken();\n            if (idToken.type !== TokenType.id) {\n                error(token);\n            }\n            const lang = idToken.value.toString();\n            this._language = Lexer.languages.find((element) => element.lang === lang) || Lexer._defaultLanguage;\n            token = this.nextToken();\n            if (token.type !== TokenType.great) {\n                error(token);\n            }\n        } else {\n            this._language = Lexer._defaultLanguage;\n            // reset reading\n            this._position = 0;\n            this._currentChar = this._source[this._position].charCodeAt(0);\n        }\n    }\n\n    private _advance() {\n        this._position++;\n        if (this._position >= this._source.length) {\n            this._currentChar = -1;\n            return;\n        }\n        this._currentChar = this._source[this._position].charCodeAt(0);\n        this._col++;\n    }\n\n    private _pick(): number {\n        if (this._position >= this._source.length) {\n            return -1;\n        }\n        return this._source[this._position].charCodeAt(0);\n    }\n\n    private _isId(code: number): boolean {\n        if (code < 48) {\n            return code === 36;\n        }\n        if (code < 58) {\n            return true;\n        }\n        if (code < 65) {\n            return false;\n        }\n        if (code < 91) {\n            return true;\n        }\n        if (code < 97) {\n            return code === 95;\n        }\n        if (code < 123) {\n            return true;\n        }\n        return false;\n    }\n\n    private _isIdStart(code: number): boolean {\n        if (code < 65) {\n            return code === 36;\n        }\n        if (code < 91) {\n            return true;\n        }\n        if (code < 97) {\n            return code === 95;\n        }\n        if (code < 123) {\n            return true;\n        }\n        return false;\n    }\n\n    private _id(): Token {\n        let ret = \"\";\n        const lastC = this._col;\n        const lastP = this._position;\n        const line = this._line;\n        while (this._isId(this._currentChar)) {\n            ret += String.fromCharCode(this._currentChar);\n            this._advance();\n        }\n        const translatedId = this._language\n            ? (this._language.keywords[ret]) || ret\n            : ret;\n        return Lexer.RESERVED[translatedId] || new Token(TokenType.id, ret, line, lastC);\n    }\n\n    private _isLineEnd(c: number): boolean {\n        return c === 10 ||\n            c === 13 ||\n            ['\\n', '\\r', '\\u2028', '\\u2029'].includes(String.fromCharCode(c));\n    }\n\n    private _isWhiteSpace(c: number): boolean {\n        return String.fromCharCode(c).trim() === \"\" &&\n            String.fromCharCode(c).length > 0;\n    }\n\n    private _isDigit(c: number): boolean {\n        // tslint:disable-next-line:no-bitwise\n        return c > 0 && (c ^ 0x30) <= 9;\n    }\n    private _skipWhiteSpace() {\n        while (this._isWhiteSpace(this._currentChar) === true) {\n            this._advance();\n        }\n    }\n\n    private _number(): Token {\n        let ret = \"\";\n        const lastC = this._col;\n        const lastP = this._position;\n        const line = this._line;\n        const first = String.fromCharCode(this._currentChar);\n        this._advance();\n        const bc = String.fromCharCode(this._currentChar);\n        let base = 10;\n        if (first === '0' && ['b', 'B', 'x', 'X', 'o', 'O'].includes(bc)) {\n            // look ahead to see that the number is tagged\n            this._advance();\n            switch (bc.toLowerCase()) {\n                case 'b':\n                    base = 2;\n                    break;\n                case \"o\":\n                    base = 8;\n                    break;\n                case \"x\":\n                    base = 16;\n                    break;\n                default:\n                    base = 10;\n            }\n        } else {\n            ret += first;\n            base = 10;\n        }\n        while (this._isDigit(this._currentChar) ||\n            (base === 16 &&\n                ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd', 'E', 'e', 'F', 'f']\n                    .includes(String.fromCharCode(this._currentChar)))) {\n            ret += String.fromCharCode(this._currentChar);\n            this._advance();\n        }\n        if (String.fromCharCode(this._currentChar) === '.' && this._isDigit(this._pick()) === true) {\n            if (base !== 10) {\n                error(new Token(TokenType.id, bc, line, lastP));\n            }\n            // floating number\n            ret += String.fromCharCode(this._currentChar);\n            this._advance();\n            while (this._isDigit(this._currentChar)) {\n                ret += String.fromCharCode(this._currentChar);\n                this._advance();\n            }\n            return new Token(TokenType.numberConst, parseFloat(ret), line, lastC);\n        }\n        return new Token(\n            TokenType.numberConst, parseInt(ret, base), line, lastC);\n    }\n\n    private _literalString(startChar: number): Token {\n        let ret = \"\";\n        let lastChar = -1;\n        const lastP = this._position;\n        const lastC = this._col;\n        const lastL = this._line;\n        while (this._currentChar !== -1) {\n            const next = String.fromCharCode(this._pick());\n            if (this._currentChar === Chars.backslash) {\n                // scape char\n                if ([\n                    startChar,\n                    '\\\\',\n                    '0',\n                    'a',\n                    'b',\n                    'e',\n                    'f',\n                    'n',\n                    'r',\n                    't',\n                    'u',\n                    'U',\n                    'v',\n                    'x'\n                ].includes(next)) {\n                    lastChar = this._currentChar;\n                    this._advance();\n                    continue;\n                }\n            }\n            if (this._currentChar === startChar && lastChar !== Chars.backslash) {\n                // end\n                break;\n            }\n\n            ret += String.fromCharCode(this._currentChar);\n            lastChar = this._currentChar;\n            this._advance();\n        }\n        return new Token(TokenType.stringConst, ret, lastL, lastC);\n    }\n\n    // f=SUBMIT_FORM(xxx);\n    // r = CALL_API(API_ID, f);\n    // DISPLAY(\"MSG #r\")\n    nextToken(): Token {\n        const lastL = this._line;\n        const lastC = this._col;\n        const lastP = this._position;\n\n        while (this._currentChar !== -1) {\n            if (this._isLineEnd(this._currentChar)) {\n                this._line++;\n                this._col = 1;\n                this._advance();\n                return new Token(TokenType.eol, \"\\n\", lastL, lastC);\n            }\n\n            if (this._isWhiteSpace(this._currentChar)) {\n                this._skipWhiteSpace();\n                continue;\n            }\n            if (this._isDigit(this._currentChar)) {\n                return this._number();\n            }\n            if (this._isIdStart(this._currentChar)) {\n                return this._id();\n            }\n            if (this._currentChar === Chars.equal) {\n                this._advance();\n                if (this._currentChar === Chars.equal) {\n                    this._advance();\n                    return new Token(TokenType.eqeq, \"==\", lastL, lastC);\n                }\n                return new Token(TokenType.equal, \"=\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.great) {\n                this._advance();\n                if (this._currentChar === Chars.equal) {\n                    this._advance();\n                    return new Token(TokenType.greatEq, \">=\", lastL, lastC);\n                }\n                return new Token(TokenType.great, \">\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.less) {\n                this._advance();\n                if (this._currentChar === Chars.equal) {\n                    this._advance();\n                    return new Token(TokenType.lessEq, \"<=\", lastL, lastC);\n                }\n                return new Token(TokenType.less, \"<\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.semiColon) {\n                this._advance();\n                return new Token(TokenType.semi, \";\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.lparen) {\n                this._advance();\n                return new Token(TokenType.lparen, \"(\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.rparen) {\n                this._advance();\n                return new Token(TokenType.rparen, \")\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.comma) {\n                this._advance();\n                return new Token(TokenType.comma, \",\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.lbrace) {\n                this._advance();\n                return new Token(TokenType.lbrace, \"{\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.rbrace) {\n                this._advance();\n                return new Token(TokenType.rbrace, \"}\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.lbracket) {\n                this._advance();\n                return new Token(TokenType.lbracket, \"[\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.rbracket) {\n                this._advance();\n                return new Token(TokenType.rbracket, \"]\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.plus) {\n                this._advance();\n                return new Token(TokenType.plus, \"+\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.minus) {\n                this._advance();\n                return new Token(TokenType.minus, \"-\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.slash) {\n                this._advance();\n                return new Token(TokenType.div, \"/\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.star) {\n                this._advance();\n                return new Token(TokenType.mult, \"*\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.percent) {\n                this._advance();\n                return new Token(TokenType.mod, \"%\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.colon) {\n                this._advance();\n                return new Token(TokenType.colon, \":\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.not) {\n                this._advance();\n                if (this._currentChar === Chars.equal) {\n                    this._advance();\n                    return new Token(TokenType.notEq, \"!=\", lastL, lastC);\n                }\n                return new Token(TokenType.not, \"!\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.and && this._pick() === Chars.and) {\n                this._advance();\n                this._advance();\n                return new Token(TokenType.and, \"&&\", lastL, lastC);\n            }\n            if (this._currentChar === Chars.pipe && this._pick() === Chars.pipe) {\n                this._advance();\n                this._advance();\n                return new Token(TokenType.and, '||', lastL, lastC);\n            }\n            if (this._currentChar === Chars.quote || this._currentChar === Chars.squote) {\n                const startChar = this._currentChar;\n                this._advance();\n                const t = this._literalString(startChar);\n                this._advance();\n                return t;\n            }\n            return new Token(\n                TokenType.invalid, String.fromCharCode(this._currentChar), lastL, lastC);\n        }\n        return new Token(TokenType.eof, \"\", lastL, lastC);\n    }\n}\n\n\n/**\n * Parser\n */\n\nabstract class AST {\n    line?: number;\n    col?: number;\n    constructor(line?: number, col?: number) {\n        this.line = line;\n        this.col = col;\n    }\n    dump(): string {\n        return this.toString();\n    }\n}\n\nclass RootAST extends AST {\n    body: AST[];\n    source: string;\n    name: string;\n    constructor(body: AST[], name: string, source: string) {\n        super(1, 1);\n        this.body = body;\n        this.name = name;\n        this.source = source;\n    }\n\n    override dump(): string {\n        let builder = `Module ${this.name} Start {`;\n        for (const it of this.body) {\n            builder += `${it.dump()}\\n`;\n        }\n        builder += \"}\";\n        return builder;\n    }\n}\n\nclass BlockStatementAST extends AST {\n    body: AST[];\n    constructor(body: AST[], token: Token) {\n        super(token.line, token.col);\n        this.body = body;\n    }\n    override toString(): string {\n        return `{\\n${this.body.map((e) => e.toString()).join(\"\\n\")}}`;\n    }\n}\n\nclass IdentifierAST extends AST {\n    value: string;\n    constructor(token: Token) {\n        super(token.line, token.col);\n        this.value = token.value.toString();\n    }\n    override toString(): string {\n        return this.value;\n    }\n}\n\nclass LiteralAST extends AST {\n    value: any;\n    raw: string;\n    constructor(token: Token, raw: string) {\n        super(token.line, token.col);\n        this.value = token.value;\n        this.raw = raw;\n    }\n    override toString(): string {\n        return this.value.toString();\n    }\n}\n\nclass AssignmentExpressionAST extends AST {\n    identifier: AST;\n    init: AST;\n    constructor(identifier: AST, init: AST) {\n        super(identifier.line, identifier.col);\n        this.identifier = identifier;\n        this.init = init;\n    }\n    override toString(): string {\n        return `${this.identifier} = ${this.init}`;\n    }\n}\n\nclass ExpressionStatementAST extends AST {\n    expression: AST;\n    constructor(expression: AST) {\n        super(expression.line, expression.col);\n        this.expression = expression;\n    }\n    override toString(): string {\n        return this.expression.toString();\n    }\n}\n\nclass CallExpressionAST extends AST {\n    callee: IdentifierAST;\n    arguments: AST[];\n    constructor(callee: IdentifierAST, ags: AST[]) {\n        super(callee.line, callee.col);\n        this.callee = callee;\n        this.arguments = ags;\n    }\n    override toString(): string {\n        return `${this.callee.toString()}(...${this.arguments.length})`;\n    }\n}\n\nclass BinaryExpressionAST extends AST {\n    left: AST;\n    operation: Token;\n    right: AST;\n    constructor(left: AST, operation: Token, right: AST) {\n        super(left.line, left.col);\n        this.left = left;\n        this.operation = operation;\n        this.right = right;\n    }\n    override toString(): string {\n        return `${this.left} ${this.operation} ${this.right}`;\n    }\n}\n\nclass UnaryExpressionAST extends AST {\n    operation: Token;\n    argument: AST;\n    constructor(operation: Token, argument: AST) {\n        super(operation.line, operation.col);\n        this.operation = operation, this.argument = argument;\n    }\n    override toString(): string {\n        return `${this.operation} ${this.argument}`;\n    }\n}\n\nclass IfStatementAST extends AST {\n    test: AST;\n    consequent: AST;\n    alternate?: AST;\n    constructor(test: AST, consequent: AST, alternate?: AST) {\n        super(test.line, test.col);\n        this.test = test;\n        this.consequent = consequent;\n        this.alternate = alternate;\n    }\n\n    override toString(): string {\n        return `if ${this.test} ${this.consequent} ${this.alternate !== null ? `else ${this.alternate} ` : ''}`;\n    }\n}\n\nclass LogicalExpressionAST extends AST {\n    left: AST;\n    operator: Token;\n    right: AST;\n    constructor(left: AST, operator: Token, right: AST) {\n        super(left.line, left.col);\n        this.left = left;\n        this.operator = operator;\n        this.right = right;\n    }\n    override toString(): string {\n        return `${this.left} ${this.operator.value} ${this.right}`;\n    }\n}\n\nclass IndexAccessorAST extends AST {\n    owner: AST;\n    key: AST;\n    computed: boolean = false;\n    constructor(owner: AST, key: AST, computed: boolean = false) {\n        super(owner.line, owner.col);\n        this.owner = owner;\n        this.key = key;\n        this.computed = computed;\n    }\n    override toString(): string {\n        return `${this.owner}[${this.key}]`;\n    }\n}\n\nclass ObjectExpression extends AST {\n    properties: AST[];\n    constructor(props: AST[], startToken?: Token, endToken?: Token) {\n        super(startToken?.line, startToken?.col);\n        this.properties = props;\n    }\n    override  toString(): string {\n        return \"{...}\";\n    }\n}\n\nclass ArrayExpression extends AST {\n    elements: AST[];\n    constructor(props: AST[], start?: AST, end?: AST) {\n        super(start?.line, start?.col);\n        this.elements = props;\n    }\n    override  toString(): string {\n        return \"[...]\";\n    }\n}\nclass ObjectProperty extends AST {\n    key: AST;\n    value: AST;\n    constructor(key: AST, value: AST) {\n        super(key.line, key.col);\n        this.value = value;\n        this.key = key;\n    }\n}\n\nclass Parser {\n    static _binopPrecdences: { [k: number]: number } = {\n        [TokenType.eqeq]: 10,\n        [TokenType.notEq]: 10,\n        [TokenType.great]: 10,\n        [TokenType.greatEq]: 10,\n        [TokenType.less]: 10,\n        [TokenType.lessEq]: 10,\n        [TokenType.plus]: 20,\n        [TokenType.minus]: 20,\n        [TokenType.mult]: 40,\n        [TokenType.div]: 40,\n        [TokenType.mod]: 40,\n    };\n    // Lexer.TokenType.AND to 9,\n    // Lexer.TokenType.OR to 9,\n    // Lexer.TokenType.BT_AND to 9,\n    // Lexer.TokenType.BT_OR to 9,\n    // Lexer.TokenType.BT_XOR to 9,\n    // Lexer.TokenType.EQUAL to 10,\n    // Lexer.TokenType.GREAT to 10,\n    // Lexer.TokenType.LESS to 10,\n    // Lexer.TokenType.LESS_EQ to 10,\n    // Lexer.TokenType.GREAT_EQ to 10,\n    // Lexer.TokenType.BT_SHIFT_L to 12,\n    // Lexer.TokenType.BT_SHIFT_R to 12,\n    // Lexer.TokenType.PLUS to 20,\n    // Lexer.TokenType.MINUS to 20,\n    // Lexer.TokenType.MULT to 40,\n    // Lexer.TokenType.DIV to 40,\n    // Lexer.TokenType.MOD to 40,\n\n    lexer!: Lexer;\n    currentToken?: Token;\n    constructor(lexer: Lexer) {\n        this.currentToken = lexer.nextToken();\n        this.lexer = lexer;\n    }\n\n    _eat(type: TokenType) {\n        if (this.currentToken?.type === type) {\n            this.currentToken = this.lexer.nextToken();\n        } else {\n            error(this.currentToken!);\n        }\n    }\n\n    _eatEOL() {\n        while (this.currentToken?.type === TokenType.eol) {\n            this._eat(TokenType.eol);\n        }\n    }\n\n    _eatSemiOrEOL() {\n        while (this.currentToken?.type === TokenType.eol ||\n            this.currentToken?.type === TokenType.semi) {\n            this._eat(this.currentToken!.type);\n        }\n    }\n\n    _eatSemi() {\n        while (this.currentToken?.type === TokenType.semi) {\n            this._eat(TokenType.semi);\n        }\n    }\n\n    _variable(): IdentifierAST {\n        const node = new IdentifierAST(this.currentToken!);\n        this._eat(TokenType.id);\n        return node;\n    }\n\n    _factor(): AST {\n        const token = this.currentToken!;\n        switch (token.type) {\n            case TokenType.plus:\n            case TokenType.minus:\n            case TokenType.not:\n                this._eat(this.currentToken!.type);\n                return new UnaryExpressionAST(token!, this._factor());\n            case TokenType.numberConst:\n                this._eat(TokenType.numberConst);\n                return new LiteralAST(token, token.value.toString());\n            case TokenType.stringConst:\n                this._eat(TokenType.stringConst);\n                return new LiteralAST(token, token.value.toString());\n            case TokenType.lparen:\n                this._eat(TokenType.lparen);\n                const node = this._expression();\n                this._eat(TokenType.rparen);\n                return node;\n            case TokenType.TRUE:\n            case TokenType.FALSE:\n                this._eat(this.currentToken!.type);\n                return new LiteralAST(token, token.value.toString());\n            case TokenType.NULL:\n                this._eat(TokenType.NULL);\n                return new LiteralAST(token, \"null\");\n            case TokenType.lbracket:\n                // literal array expression\n                return this._arrayExpression();\n            case TokenType.lbrace:\n                return this._objectExpression();\n            default:\n                return this._variable();\n        }\n    }\n\n    _term(): AST {\n        let node = this._factor();\n        node = this._tryParsingMemberExpression(node);\n        node = this._tryParsingFunctionCall(node);\n        return node;\n    }\n\n    _expression(): AST {\n        let node = this._term();\n        node = this._tryBinaryExpression(0, node);\n        while ([TokenType.and, TokenType.or].includes(this.currentToken!.type)) {\n            const token = this.currentToken!;\n            this._eat(token.type);\n            node = new LogicalExpressionAST(node, token, this._expression());\n        }\n        if (this._expect(TokenType.equal)) {\n            if (node instanceof IdentifierAST || node instanceof IndexAccessorAST) {\n                const token = this.currentToken!;\n                this._eat(TokenType.equal);\n                node = new AssignmentExpressionAST(node, this._expression());\n            } else {\n                throw new Error(\"Unexpected token\");\n            }\n        }\n        return node;\n    }\n    _objectProperty(): ObjectProperty {\n        let key: AST;\n        switch (this.currentToken?.type) {\n            case TokenType.stringConst:\n                {\n                    key = new LiteralAST(this.currentToken, this.currentToken.value);\n                    this._eat(TokenType.stringConst);\n                    break;\n                }\n            case TokenType.lbracket:\n                {\n                    this._eat(TokenType.lbracket);\n                    var expr = this._expression();\n                    this._eat(TokenType.rbracket);\n                    key = expr;\n                    break;\n                }\n            case TokenType.id:\n                {\n                    const id = this._variable();\n                    key = new LiteralAST(new Token(TokenType.id, id.value, id.line, id.col), id.value);\n                    break;\n                }\n            default:\n                throw `Unexpected token ${this.currentToken}`;\n        }\n        this._eat(TokenType.colon);\n        var value = this._expression();\n        return new ObjectProperty(key!, value);\n    }\n    _property(): AST {\n        return this._objectProperty();\n    }\n\n    _objectProperties(): AST[] {\n        const properties: AST[] = [];\n        if (this.currentToken?.type != TokenType.rbrace) {\n            properties.push(this._property());\n        }\n        while (this.currentToken?.type == TokenType.comma) {\n            this._eat(TokenType.comma);\n            properties.push(this._property());\n        }\n        return properties;\n    }\n\n    _objectExpression(braceToken?: Token): AST {\n        var token = braceToken ?? this.currentToken;\n        if (!braceToken) this._eat(TokenType.lbrace);\n        var properties = this._objectProperties();\n        this._eat(TokenType.rbrace);\n        return new ObjectExpression(properties, token, this.currentToken);\n    }\n\n    _arrayExpression(): AST {\n        this._eat(TokenType.lbracket);\n        const elements: AST[] = this._expect(TokenType.rbracket) ? [] : this._expressionsList();\n        this._eat(TokenType.rbracket);\n        var startNode = elements.length !== 0 ? elements[0] : undefined;\n        var lastNode = elements.length !== 0 ? elements[elements.length - 1] : undefined;\n        return new ArrayExpression(elements, startNode, lastNode);\n    }\n    _tryParsingMemberExpression(n: AST): AST {\n        let node = n;\n        while (this.currentToken!.type === TokenType.lbracket) {\n            this._eat(TokenType.lbracket);\n            const key = this._expression();\n            node = new IndexAccessorAST(node, key);\n            this._eat(TokenType.rbracket);\n        }\n        return node;\n    }\n\n    _tryBinaryExpression(prec: number, left: AST): AST {\n        let node = left;\n        while (true) {\n            const currentPrec = Parser._binopPrecdences[this.currentToken!.type] || -1;\n            if (currentPrec < prec) return node;\n            const operator = this.currentToken!;\n            this._eat(operator.type);\n            let right = this._term();\n            const nextPrec = Parser._binopPrecdences[this.currentToken!.type] || -1;\n            if (currentPrec < nextPrec) {\n                const tmp = this._tryBinaryExpression(currentPrec + 1, right);\n                if (tmp === node) return tmp;\n                right = tmp;\n            }\n            node = new BinaryExpressionAST(node, operator, right);\n        }\n    }\n\n    _expressionsList(): AST[] {\n        this._eatEOL();\n        // if (expect(Lexer.TokenType.RPAREN)) return emptyList()\n        let expr = this._expression();\n        const result = [expr];\n        while (this.currentToken?.type === TokenType.comma) {\n            this._eat(TokenType.comma);\n            expr = this._expression();\n            result.push(expr);\n        }\n        return result;\n    }\n\n    _callExpression(node: AST): CallExpressionAST {\n        this._eat(TokenType.lparen);\n        let args: AST[] = [];\n        if (!this._expect(TokenType.rparen)) {\n            args = this._expressionsList();\n        }\n        this._eat(TokenType.rparen);\n        if (!(node instanceof IdentifierAST)) {\n            error(this.currentToken!);\n        }\n        return new CallExpressionAST(node as IdentifierAST, args);\n    }\n\n    _tryParsingFunctionCall(n: AST): AST {\n        let node = n;\n        while (this.currentToken!.type === TokenType.lparen) {\n            // probable function call\n            node = this._callExpression(node);\n        }\n        return node;\n    }\n\n    _statementExpression(): AST {\n\n        const node = this._expression();\n\n        if (![TokenType.semi, TokenType.eol, TokenType.eof]\n            .includes(this.currentToken!.type)) {\n            error(this.currentToken!);\n        }\n        return node;\n    }\n\n    _blockStatement(ignoreFirstBrace = false): BlockStatementAST {\n        if (!ignoreFirstBrace) this._eat(TokenType.lbrace);\n        this._eatEOL();\n        if (this._expect(TokenType.rbrace)) {\n            this._eat(TokenType.rbrace);\n            return new BlockStatementAST([], this.currentToken!);\n        }\n        // const body = _statements();\n        const body = [this._statement()];\n        while (this.currentToken!.type === TokenType.eol ||\n            this.currentToken!.type === TokenType.semi) {\n            this._eatSemiOrEOL();\n            if (this.currentToken!.type === TokenType.rbrace || this.currentToken!.type === TokenType.eof) {\n                // _eat(this.currentToken!.type);\n                break;\n            }\n            body.push(this._statement());\n            if (this.currentToken!.type !== TokenType.eol &&\n                this.currentToken!.type !== TokenType.semi &&\n                this.currentToken!.type !== TokenType.eof) {\n                error(this.currentToken!);\n            }\n        }\n        this._eat(TokenType.rbrace);\n        if (this.currentToken?.type === TokenType.rbrace) {\n            // endBlock\n            this._eat(TokenType.rbrace);\n        }\n\n        return new BlockStatementAST(body, this.currentToken!);\n    }\n\n    _ifStatement(): IfStatementAST {\n        this._eat(TokenType.IF);\n        const withPar = this.currentToken!.type === TokenType.lparen;\n        if (withPar) {\n            this._eat(TokenType.lparen);\n        }\n        const test = this._expression();\n        if (withPar) {\n            this._eat(TokenType.rparen);\n        }\n        let consequent: AST;\n        if (this.currentToken!.type === TokenType.lbrace) {\n            consequent = this._blockStatement();\n        } else {\n            consequent = this._expression();\n        }\n        this._eatSemiOrEOL();\n        let alternate: AST | undefined;\n        if (this.currentToken!.type === TokenType.ELSE) {\n            this._eat(TokenType.ELSE);\n            switch (this.currentToken!.type) {\n                case TokenType.IF:\n                    alternate = this._ifStatement();\n                    break;\n                case TokenType.lbrace:\n                    alternate = this._blockStatement();\n                    break;\n                default:\n                    alternate = this._expression();\n            }\n        }\n        return new IfStatementAST(test, consequent, alternate);\n    }\n\n    _statement(): AST {\n        switch (this.currentToken!.type) {\n            case TokenType.semi:\n                this._eatSemi();\n                return this._statement();\n            case TokenType.eol:\n                this._eatEOL();\n                return this._statement();\n            case TokenType.IF:\n                return this._ifStatement();\n            default:\n                return this._statementExpression();\n        }\n    }\n\n    _expect(type: TokenType) {\n        return this.currentToken?.type === type;\n    }\n    _statements(): AST[] {\n        this._eatEOL();\n\n        if (this._expect(TokenType.eof)) {\n            return [];\n        }\n        const results = [this._statement()];\n        while ((this.currentToken!.type === TokenType.eol ||\n            this.currentToken!.type === TokenType.semi)) {\n            this._eatSemiOrEOL();\n            if (this.currentToken!.type === TokenType.eof) {\n                this._eat(TokenType.eof);\n                break;\n            }\n            results.push(this._statement());\n            if (this.currentToken!.type !== TokenType.eol &&\n                this.currentToken!.type !== TokenType.semi &&\n                this.currentToken!.type !== TokenType.eof) {\n                error(this.currentToken!);\n            }\n        }\n        return results;\n    }\n\n    _root(): RootAST {\n        const source = this.lexer.source;\n        const name = \"<module>\";\n        const list = this._statements();\n        return new RootAST(list, name, source);\n    }\n\n    parse(): AST {\n        return this._root();\n    }\n}\ntype Func = (node: any) => any;\n// AST Wallker\nabstract class ANodeVisitor {\n    protected _nodesVisitors: { [k: string]: Func } = {};\n    protected registerVisitor(type: Type<AST>, visitor: Func) {\n        const methodName = `visit${type.name}`;\n        // console.log('Reg::::::', methodName, type);\n        this._nodesVisitors[methodName] = visitor;\n    }\n\n    abstract visit(node: AST): any;\n}\n\nabstract class AsyncNodeVisitor extends ANodeVisitor {\n    override async visit(node: AST): Promise<any> {\n        const methodName = `visit${node.constructor.name}`;\n        // const fn = Object.getPrototypeOf(this)[methodName];\n        const fn = this._nodesVisitors[methodName];\n        return await fn?.call(this, node);\n    }\n}\n\nabstract class NodeVisitor extends ANodeVisitor {\n    override visit(node: AST): any {\n        const methodName = `visit${node.constructor.name}`;\n        // const fn = Object.getPrototypeOf(this)[methodName];\n        const fn = this._nodesVisitors[methodName];\n        return fn?.call(this, node);\n    }\n}\n\ntype MEventoFBinding = (args: any[], vm: MEvento) => any;\nexport class MEvento extends NodeVisitor {\n    _memory: { [k: string]: any } = {};\n    private static _globalFunctionsRegistry: { [k: string]: MEventoFBinding } = {};\n    private static _cache: Map<number, AST> = new Map();\n    _functionsRegistry: { [k: string]: MEventoFBinding } = {};\n    constructor() {\n        super();\n        this.registerVisitor(RootAST, this.visitRootAST);\n        this.registerVisitor(BlockStatementAST, this.visitBlockStatementAST);\n        this.registerVisitor(IdentifierAST, this.visitIdentifierAST);\n        this.registerVisitor(LiteralAST, this.visitLiteralAST);\n        this.registerVisitor(AssignmentExpressionAST, this.visitAssignmentExpressionAST);\n        this.registerVisitor(ExpressionStatementAST, this.visitExpressionStatementAST);\n        this.registerVisitor(CallExpressionAST, this.visitCallExpressionAST);\n        this.registerVisitor(BinaryExpressionAST, this.visitBinaryExpressionAST);\n        this.registerVisitor(UnaryExpressionAST, this.visitUnaryExpressionAST);\n        this.registerVisitor(IfStatementAST, this.visitIfStatementAST);\n        this.registerVisitor(LogicalExpressionAST, this.visitLogicalExpressionAST);\n        this.registerVisitor(IndexAccessorAST, this.visitIndexAccessorAST);\n        this.registerVisitor(ObjectProperty, this.visitObjectProperty);\n        this.registerVisitor(ObjectExpression, this.visitObjectExpression);\n        this.registerVisitor(ArrayExpression, this.visitArrayExpression);\n\n        this._functionsRegistry = { ...MEvento._globalFunctionsRegistry };\n    }\n\n    protected visitRootAST(node: RootAST): any {\n        const list = node.body;\n        let last;\n        for (const n of list) {\n            last = this.visit(n);\n        }\n        return last;\n    }\n\n    protected visitBlockStatementAST(node: BlockStatementAST): any {\n        const list = node.body;\n        let last;\n        for (const n of list) {\n            last = this.visit(n);\n        }\n        return last;\n    }\n\n    protected visitIdentifierAST(node: IdentifierAST): any {\n        const id = node.value;\n        return this._memory[id];\n    }\n\n    protected visitLiteralAST(node: AST): any {\n        const value = (node as LiteralAST).value;\n        return value;\n    }\n\n    protected visitAssignmentExpressionAST(node: AssignmentExpressionAST): any {\n\n        const id: AST = node.identifier;\n\n        const init: AST = node.init;\n        let value: any = null;\n        if (id instanceof IndexAccessorAST) {\n            var target = this.visit(id.owner);\n            value = this.visit(node.init);\n            var property = this.visit(id.key);\n            this.assignProperty(target, property, value);\n        } else if (id instanceof IdentifierAST) {\n            value = this.visit(init);\n            this._memory[id.value] = value;\n        }\n        return value;\n    }\n    assignProperty(owner: any, property: any, value: any): any {\n        if (Array.isArray(owner)) {\n            owner[property] = value;\n        } else if (typeof owner === 'object') {\n            owner[property] = value;\n        } else { }\n    }\n\n    protected visitExpressionStatementAST(node: ExpressionStatementAST): any {\n        const expr = node.expression;\n        return this.visit(expr);\n    }\n\n    protected visitCallExpressionAST(node: CallExpressionAST) {\n        const callee = node.callee;\n        const args = node.arguments;\n        const calleeName = callee.value;\n        const fn = this._functionsRegistry[calleeName];\n        const argValues = args.map((e) => this.visit(e));\n        // print(\"argValues::\", argValues)\n        return fn?.(argValues, this);\n    }\n\n    protected visitBinaryExpressionAST(node: BinaryExpressionAST): any {\n        const left = node.left;\n        const right = node.right;\n        const op = node.operation;\n        const lValue = this.visit(left);\n        const rValue = this.visit(right);\n        switch (op.type) {\n            case TokenType.plus:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue + rValue;\n                }\n                return `${lValue}${rValue}`;\n            case TokenType.minus:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue - rValue;\n                }\n                if (isString(lValue) && isNum(rValue)) {\n                    return lValue * rValue;\n                }\n                if (isNum(lValue) && isString(rValue)) {\n                    return rValue * lValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.mult:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue * rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.div:\n                if (isNum(lValue) && isNum(rValue)) {\n                    if (rValue === 0) {\n                        throw new Error(\"Invalid division by 0\");\n                    }\n                    return lValue / rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.mod:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue % rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.great:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue > rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.greatEq:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue >= rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.less:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue < rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.lessEq:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue <= rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.eqeq:\n                return lValue === rValue;\n            case TokenType.notEq:\n                return lValue !== rValue;\n            default:\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n        }\n    }\n\n    protected visitUnaryExpressionAST(node: UnaryExpressionAST): any {\n        const arg = node.argument;\n        const op = node.operation;\n        const argValue = this.visit(arg);\n        if(op.type === TokenType.not) {\n            return _boolValue(argValue) === false;\n        }\n        if (isNum(argValue)) {\n            throw new Error(`Operation ${op.value} not allowed no num value`);\n        }\n        if (op.type === TokenType.plus) {\n            return argValue;\n        } else if (op.type === TokenType.minus) {\n            return -argValue;\n        }\n        throw new Error(`Operation ${op.value} not allowed no num value`);\n    }\n\n    protected visitIfStatementAST(node: IfStatementAST): any {\n        const testNode: AST = node.test;\n        const test = this.visit(testNode);\n        const testBoolValue = _boolValue(test);\n\n        if (testBoolValue) {\n            return this.visit(node.consequent);\n        }\n        if (node.alternate !== null) {\n            return this.visit(node.alternate!);\n        }\n\n        return null;\n    }\n\n\n\n    protected visitLogicalExpressionAST(node: LogicalExpressionAST): any {\n        const leftNode = node.left;\n        const test = this.visit(leftNode);\n        const testBoolValue = _boolValue(test);\n        if (node.operator.type === TokenType.and) {\n            return testBoolValue && _boolValue(this.visit(node.right));\n        }\n        if (node.operator.type === TokenType.or) {\n            return testBoolValue || _boolValue(this.visit(node.right));\n        }\n        return false;\n    }\n\n    protected visitIndexAccessorAST(node: IndexAccessorAST): any {\n        const ownerNode = (node as IndexAccessorAST).owner;\n        const owner = this.visit(ownerNode);\n        if (typeof owner === 'object') {\n            const key = this.visit(node.key);\n            return owner[key];\n        } else if (Array.isArray(owner)) {\n            const key = this.visit(node.key);\n            return isNum(key) && owner.length < key && key >= 0 ? owner[key] : null;\n        }\n        return null;\n    }\n\n    protected visitObjectProperty(node: AST): any { }\n\n    protected visitObjectExpression(ast: AST): any {\n        const instance: any = {};\n        const node = ast as ObjectExpression;\n        for (const it of node.properties) {\n            if (it instanceof ObjectProperty) {\n                let key = this.visit(it.key);\n                key = isString(key) ? key : key.toString();\n                instance[key] = this.visit(it.value);\n            }\n        }\n        return instance;\n    }\n\n    protected visitArrayExpression(ast: AST): any {\n        const node = ast as ArrayExpression;\n        const args = this.resolveArguments(node.elements);\n        return args;\n    }\n\n    resolveArguments(args: AST[]): any {\n        return args.map((it: AST) => {\n            return this.visit(it);\n        });\n    }\n\n    registerFunction(id: string, fn: MEventoFBinding) {\n        this._functionsRegistry[id] = fn;\n    }\n\n    unregisterFunction(id: string) {\n        delete this._functionsRegistry[id];\n    }\n\n    execute(source: string, cache = true) {\n        const module = MEvento.compile(source, cache);\n        return this.visit(module);\n    }\n\n    static compile(source: string, cache = false): AST {\n        const hash = hashCode(source);\n        if (cache && this._cache.has(hash)) {\n            return this._cache.get(hash)!;\n        }\n        const lexer = new Lexer(source);\n        const parser = new Parser(lexer);\n        const module = parser.parse();\n        if (cache) this._cache.set(hash, module);\n        return module;\n    }\n\n    static register(id: string, fn: MEventoFBinding) {\n        MEvento._globalFunctionsRegistry[id] = fn;\n    }\n\n    static unregister(id: string) {\n        delete MEvento._globalFunctionsRegistry[id];\n    }\n\n    static run(source: string, cache = false) {\n        const mevento = new MEvento();\n        const module = MEvento.compile(source, cache);\n        return mevento.visit(module);\n    }\n\n    static newInstance(): MEvento {\n        // const lexer = Lexer(source);\n        // const parser = Parser(lexer);\n        // const module = parser.parse();\n        return new MEvento();\n    }\n   \n    clone(): MEvento {\n        var ret = new MEvento();\n        ret._functionsRegistry = { ... this._functionsRegistry };\n        ret._memory = { ...this._memory };\n        return ret;\n    }\n    newAsyncInstance(): MEventoAsync {\n        const asyncIns =  MEventoAsync.newInstance();\n        asyncIns._memory = this._memory;\n        /// ????\n        asyncIns._functionsRegistry = this._functionsRegistry;\n        return asyncIns;\n    };\n\n}\n\nexport class MEventoAsync extends MEvento {\n    constructor() {\n        super();\n    }\n\n    protected override async visitRootAST(node: RootAST) {\n        const list = node.body;\n        let last;\n        for (const n of list) {\n            last = await this.visit(n);\n        }\n        return last;\n    }\n    protected override async visitBlockStatementAST(node: BlockStatementAST): Promise<any> {\n        const list = node.body;\n        let last;\n        for (const n of list) {\n            last = await this.visit(n);\n        }\n        return last;\n    }\n    protected override async visitIdentifierAST(node: AST): Promise<any> {\n        const id = (node as IdentifierAST).value;\n        return this._memory[id];\n    }\n    protected override async visitLiteralAST(node: LiteralAST): Promise<any> {\n        const value = node.value;\n        return value;\n    }\n    protected override async visitAssignmentExpressionAST(node: AssignmentExpressionAST) {\n        const id: AST = node.identifier;\n\n        const init: AST = node.init;\n        let value: any = null;\n        if (id instanceof IndexAccessorAST) {\n            var target = await this.visit(id.owner);\n            value = await this.visit(node.init);\n            var property = await this.visit(id.key);\n            this.assignProperty(target, property, value);\n        } else if (id instanceof IdentifierAST) {\n            value = await this.visit(init);\n            this._memory[id.value] = value;\n        }\n        return value;\n    }\n    protected override async visitExpressionStatementAST(node: ExpressionStatementAST) {\n        const expr = node.expression;\n        return await this.visit(expr);\n    }\n    protected override async visitCallExpressionAST(node: CallExpressionAST) {\n        const callee = node.callee;\n        const args = node.arguments;\n        const calleeName = callee.value;\n        const fn = this._functionsRegistry[calleeName];\n        const argValues = await Promise.all(args.map((e) => this.visit(e)));\n        // print(\"argValues::\", argValues)\n        return await fn?.(argValues, this);\n    }\n    protected override async visitBinaryExpressionAST(node: BinaryExpressionAST) {\n        const left = node.left;\n        const right = node.right;\n        const op = node.operation;\n        const lValue = await this.visit(left);\n        const rValue = await this.visit(right);\n        switch (op.type) {\n            case TokenType.plus:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue + rValue;\n                }\n                return `${lValue}${rValue}`;\n            case TokenType.minus:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue - rValue;\n                }\n                if (isString(lValue) && isNum(rValue)) {\n                    return lValue * rValue;\n                }\n                if (isNum(lValue) && isString(rValue)) {\n                    return rValue * lValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.mult:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue * rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.div:\n                if (isNum(lValue) && isNum(rValue)) {\n                    if (rValue === 0) {\n                        throw new Error(\"Invalid division by 0\");\n                    }\n                    return lValue / rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.mod:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue % rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.great:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue > rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.greatEq:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue >= rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.less:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue < rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.lessEq:\n                if (isNum(lValue) && isNum(rValue)) {\n                    return lValue <= rValue;\n                }\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n            case TokenType.eqeq:\n                return lValue === rValue;\n            case TokenType.notEq:\n                return lValue !== rValue;\n            default:\n                throw new Error(`Operation ${op.value} not allowed no num value`);\n        }\n    }\n    protected override async visitUnaryExpressionAST(node: UnaryExpressionAST) {\n        const arg = node.argument;\n        const op = node.operation;\n        const argValue = await this.visit(arg);\n        if (isNum(argValue)) {\n            throw new Error(`Operation ${op.value} not allowed no num value`);\n        }\n        if (op.type === TokenType.plus) {\n            return argValue;\n        } else if (op.type === TokenType.minus) {\n            return -argValue;\n        }\n        throw new Error(`Operation ${op.value} not allowed no num value`);\n    }\n    protected override  async visitIfStatementAST(node: IfStatementAST) {\n        const testNode: AST = node.test;\n        const test = await this.visit(testNode);\n        const testBoolValue = _boolValue(test);\n\n        if (testBoolValue) {\n            return await this.visit(node.consequent);\n        }\n        if (node.alternate !== null) {\n            return await this.visit(node.alternate!);\n        }\n\n        return null;\n    }\n    protected override async visitLogicalExpressionAST(node: LogicalExpressionAST) {\n        const leftNode = node.left;\n        const test = await this.visit(leftNode);\n        const testBoolValue = _boolValue(test);\n        if (node.operator.type === TokenType.and) {\n            return testBoolValue && _boolValue(await this.visit(node.right));\n        }\n        if (node.operator.type === TokenType.or) {\n            return testBoolValue || _boolValue(await this.visit(node.right));\n        }\n        return false;\n    }\n    protected override async visitIndexAccessorAST(node: IndexAccessorAST) {\n        const ownerNode = (node as IndexAccessorAST).owner;\n        const owner = await this.visit(ownerNode);\n        if (typeof owner === 'object') {\n            const key = await this.visit(node.key);\n            return owner[key];\n        } else if (Array.isArray(owner)) {\n            const key = await this.visit(node.key);\n            return isNum(key) && owner.length < key && key >= 0 ? owner[key] : null;\n        }\n        return null;\n    }\n    protected override async visitObjectProperty(node: AST) { }\n\n    protected override async visitObjectExpression(ast: AST) {\n        const instance: any = {};\n        const node = ast as ObjectExpression;\n        for (const it of node.properties) {\n            if (it instanceof ObjectProperty) {\n                let key = await this.visit(it.key);\n                key = isString(key) ? key : key.toString();\n                instance[key] = await this.visit(it.value);\n            }\n        }\n        return instance;\n    }\n\n    protected override async visitArrayExpression(ast: AST) {\n        const node = ast as ArrayExpression;\n        const args = await this.resolveArgumentsAsync(node.elements);\n        return args;\n    }\n\n    async resolveArgumentsAsync(args: AST[]): Promise<any[]> {\n        return await Promise.all(args.map(async (it: AST) => {\n            return await this.visit(it);\n        }));\n    }\n    override registerFunction(id: string, fn: MEventoFBinding) {\n        this._functionsRegistry[id] = fn;\n    }\n\n    override unregisterFunction(id: string) {\n        delete this._functionsRegistry[id];\n    }\n    override  async execute(source: string, cache = true) {\n        const module = MEvento.compile(source, cache);\n        return await this.visit(module);\n    }\n\n    static override async run(source: string, cache = false) {\n        const mevento = new MEventoAsync();\n        const module = MEvento.compile(source, cache);\n        return await mevento.visit(module);\n    }\n\n    static override newInstance(): MEventoAsync {\n        // const lexer = Lexer(source);\n        // const parser = Parser(lexer);\n        // const module = parser.parse();\n        return new MEventoAsync();\n    }\n\n\n    override clone(): MEventoAsync {\n        var ret = new MEventoAsync();\n        ret._functionsRegistry = { ...this._functionsRegistry };\n        ret._memory = { ...this._memory };\n        return ret;\n    }\n}\n"]}