mevento 1.0.0

package/fesm2020/mevento.mjs

@@ -0,0 +1,1570 @@
+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);
+    }
+}
+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();
+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;
+    }
+}
+
+/*
+ * Public API Surface of mevento
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { MEvento, MEventoAsync };
+//# sourceMappingURL=mevento.mjs.map