@guardian-network/policy-dsl 0.3.2

package/dist/antlr/generated/grammar/LacLangParser.js

@@ -0,0 +1,1399 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteralContext = exports.Identifier_or_literalContext = exports.ArgumentsListContext = exports.ConstantsListContext = exports.DataTypeContext = exports.EvaluateStatementContext = exports.InstanceDeclarationContext = exports.ArtifactDeclarationContext = exports.ConstantDeclarationContext = exports.InjectionModifierContext = exports.VarDeclarationContext = exports.InjectedOnlyDirectiveContext = exports.DirectiveIndentifierContext = exports.DirectiveContext = exports.ImportStatementContext = exports.StatementContext = exports.ProgramContext = exports.LacLangParser = void 0;
+const ATN_1 = require("antlr4ts/atn/ATN");
+const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
+const ParserATNSimulator_1 = require("antlr4ts/atn/ParserATNSimulator");
+const FailedPredicateException_1 = require("antlr4ts/FailedPredicateException");
+const NoViableAltException_1 = require("antlr4ts/NoViableAltException");
+const Parser_1 = require("antlr4ts/Parser");
+const ParserRuleContext_1 = require("antlr4ts/ParserRuleContext");
+const RecognitionException_1 = require("antlr4ts/RecognitionException");
+const Token_1 = require("antlr4ts/Token");
+const VocabularyImpl_1 = require("antlr4ts/VocabularyImpl");
+const Utils = __importStar(require("antlr4ts/misc/Utils"));
+class LacLangParser extends Parser_1.Parser {
+    static T__0 = 1;
+    static T__1 = 2;
+    static T__2 = 3;
+    static T__3 = 4;
+    static T__4 = 5;
+    static T__5 = 6;
+    static T__6 = 7;
+    static T__7 = 8;
+    static T__8 = 9;
+    static T__9 = 10;
+    static T__10 = 11;
+    static T__11 = 12;
+    static T__12 = 13;
+    static T__13 = 14;
+    static T__14 = 15;
+    static T__15 = 16;
+    static T__16 = 17;
+    static T__17 = 18;
+    static T__18 = 19;
+    static T__19 = 20;
+    static T__20 = 21;
+    static WITH_KEYWORD = 22;
+    static ADDRESS_LITERAL = 23;
+    static BOOL_LITERAL = 24;
+    static NUMBER_LITERAL = 25;
+    static STRING_LITERAL = 26;
+    static BYTES_LITERAL = 27;
+    static IDENTIFIER = 28;
+    static WHITESPACE = 29;
+    static COMMENT = 30;
+    static RULE_program = 0;
+    static RULE_statement = 1;
+    static RULE_importStatement = 2;
+    static RULE_directive = 3;
+    static RULE_directiveIndentifier = 4;
+    static RULE_injectedOnlyDirective = 5;
+    static RULE_varDeclaration = 6;
+    static RULE_injectionModifier = 7;
+    static RULE_constantDeclaration = 8;
+    static RULE_artifactDeclaration = 9;
+    static RULE_instanceDeclaration = 10;
+    static RULE_evaluateStatement = 11;
+    static RULE_dataType = 12;
+    static RULE_constantsList = 13;
+    static RULE_argumentsList = 14;
+    static RULE_identifier_or_literal = 15;
+    static RULE_literal = 16;
+    static ruleNames = [
+        'program',
+        'statement',
+        'importStatement',
+        'directive',
+        'directiveIndentifier',
+        'injectedOnlyDirective',
+        'varDeclaration',
+        'injectionModifier',
+        'constantDeclaration',
+        'artifactDeclaration',
+        'instanceDeclaration',
+        'evaluateStatement',
+        'dataType',
+        'constantsList',
+        'argumentsList',
+        'identifier_or_literal',
+        'literal',
+    ];
+    static _LITERAL_NAMES = [
+        undefined,
+        "'import'",
+        "';'",
+        "'pragma'",
+        "'injected-only'",
+        "'var'",
+        "'inject'",
+        "'('",
+        "')'",
+        "'constant'",
+        "'='",
+        "'artifact'",
+        "'instance'",
+        "'of'",
+        "'takes'",
+        "'evaluate'",
+        "'bool'",
+        "'number'",
+        "'string'",
+        "'bytes'",
+        "'address'",
+        "','",
+        "'with'",
+    ];
+    static _SYMBOLIC_NAMES = [
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        'WITH_KEYWORD',
+        'ADDRESS_LITERAL',
+        'BOOL_LITERAL',
+        'NUMBER_LITERAL',
+        'STRING_LITERAL',
+        'BYTES_LITERAL',
+        'IDENTIFIER',
+        'WHITESPACE',
+        'COMMENT',
+    ];
+    static VOCABULARY = new VocabularyImpl_1.VocabularyImpl(LacLangParser._LITERAL_NAMES, LacLangParser._SYMBOLIC_NAMES, []);
+    get vocabulary() {
+        return LacLangParser.VOCABULARY;
+    }
+    get grammarFileName() {
+        return 'LacLang.g4';
+    }
+    get ruleNames() {
+        return LacLangParser.ruleNames;
+    }
+    get serializedATN() {
+        return LacLangParser._serializedATN;
+    }
+    createFailedPredicateException(predicate, message) {
+        return new FailedPredicateException_1.FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this._interp = new ParserATNSimulator_1.ParserATNSimulator(LacLangParser._ATN, this);
+    }
+    program() {
+        let _localctx = new ProgramContext(this._ctx, this.state);
+        this.enterRule(_localctx, 0, LacLangParser.RULE_program);
+        try {
+            let _alt;
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 37;
+                this._errHandler.sync(this);
+                _alt = this.interpreter.adaptivePredict(this._input, 0, this._ctx);
+                while (_alt !== 1 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1 + 1) {
+                        {
+                            {
+                                this.state = 34;
+                                this.importStatement();
+                            }
+                        }
+                    }
+                    this.state = 39;
+                    this._errHandler.sync(this);
+                    _alt = this.interpreter.adaptivePredict(this._input, 0, this._ctx);
+                }
+                this.state = 43;
+                this._errHandler.sync(this);
+                _alt = this.interpreter.adaptivePredict(this._input, 1, this._ctx);
+                while (_alt !== 1 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1 + 1) {
+                        {
+                            {
+                                this.state = 40;
+                                this.directive();
+                            }
+                        }
+                    }
+                    this.state = 45;
+                    this._errHandler.sync(this);
+                    _alt = this.interpreter.adaptivePredict(this._input, 1, this._ctx);
+                }
+                this.state = 49;
+                this._errHandler.sync(this);
+                _alt = this.interpreter.adaptivePredict(this._input, 2, this._ctx);
+                while (_alt !== 1 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1 + 1) {
+                        {
+                            {
+                                this.state = 46;
+                                this.statement();
+                            }
+                        }
+                    }
+                    this.state = 51;
+                    this._errHandler.sync(this);
+                    _alt = this.interpreter.adaptivePredict(this._input, 2, this._ctx);
+                }
+                this.state = 52;
+                this.match(LacLangParser.EOF);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    statement() {
+        let _localctx = new StatementContext(this._ctx, this.state);
+        this.enterRule(_localctx, 2, LacLangParser.RULE_statement);
+        try {
+            this.state = 59;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case LacLangParser.T__4:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 54;
+                        this.varDeclaration();
+                    }
+                    break;
+                case LacLangParser.T__8:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 55;
+                        this.constantDeclaration();
+                    }
+                    break;
+                case LacLangParser.T__10:
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 56;
+                        this.artifactDeclaration();
+                    }
+                    break;
+                case LacLangParser.T__11:
+                    this.enterOuterAlt(_localctx, 4);
+                    {
+                        this.state = 57;
+                        this.instanceDeclaration();
+                    }
+                    break;
+                case LacLangParser.T__14:
+                    this.enterOuterAlt(_localctx, 5);
+                    {
+                        this.state = 58;
+                        this.evaluateStatement();
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    importStatement() {
+        let _localctx = new ImportStatementContext(this._ctx, this.state);
+        this.enterRule(_localctx, 4, LacLangParser.RULE_importStatement);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 61;
+                this.match(LacLangParser.T__0);
+                this.state = 62;
+                this.match(LacLangParser.STRING_LITERAL);
+                this.state = 63;
+                this.match(LacLangParser.T__1);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    directive() {
+        let _localctx = new DirectiveContext(this._ctx, this.state);
+        this.enterRule(_localctx, 6, LacLangParser.RULE_directive);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 65;
+                this.match(LacLangParser.T__2);
+                this.state = 66;
+                this.directiveIndentifier();
+                this.state = 67;
+                this.match(LacLangParser.T__1);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    directiveIndentifier() {
+        let _localctx = new DirectiveIndentifierContext(this._ctx, this.state);
+        this.enterRule(_localctx, 8, LacLangParser.RULE_directiveIndentifier);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 69;
+                this.injectedOnlyDirective();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    injectedOnlyDirective() {
+        let _localctx = new InjectedOnlyDirectiveContext(this._ctx, this.state);
+        this.enterRule(_localctx, 10, LacLangParser.RULE_injectedOnlyDirective);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 71;
+                this.match(LacLangParser.T__3);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    varDeclaration() {
+        let _localctx = new VarDeclarationContext(this._ctx, this.state);
+        this.enterRule(_localctx, 12, LacLangParser.RULE_varDeclaration);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 73;
+                this.match(LacLangParser.T__4);
+                this.state = 75;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === LacLangParser.T__5) {
+                    {
+                        this.state = 74;
+                        this.injectionModifier();
+                    }
+                }
+                this.state = 77;
+                this.dataType();
+                this.state = 78;
+                this.match(LacLangParser.IDENTIFIER);
+                this.state = 79;
+                this.match(LacLangParser.T__1);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    injectionModifier() {
+        let _localctx = new InjectionModifierContext(this._ctx, this.state);
+        this.enterRule(_localctx, 14, LacLangParser.RULE_injectionModifier);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 81;
+                this.match(LacLangParser.T__5);
+                this.state = 82;
+                this.match(LacLangParser.T__6);
+                this.state = 83;
+                this.match(LacLangParser.STRING_LITERAL);
+                this.state = 84;
+                this.match(LacLangParser.T__7);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    constantDeclaration() {
+        let _localctx = new ConstantDeclarationContext(this._ctx, this.state);
+        this.enterRule(_localctx, 16, LacLangParser.RULE_constantDeclaration);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 86;
+                this.match(LacLangParser.T__8);
+                this.state = 87;
+                this.dataType();
+                this.state = 88;
+                this.match(LacLangParser.IDENTIFIER);
+                this.state = 89;
+                this.match(LacLangParser.T__9);
+                this.state = 90;
+                this.literal();
+                this.state = 91;
+                this.match(LacLangParser.T__1);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    artifactDeclaration() {
+        let _localctx = new ArtifactDeclarationContext(this._ctx, this.state);
+        this.enterRule(_localctx, 18, LacLangParser.RULE_artifactDeclaration);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 93;
+                this.match(LacLangParser.T__10);
+                this.state = 94;
+                this.match(LacLangParser.IDENTIFIER);
+                this.state = 95;
+                this.match(LacLangParser.T__9);
+                this.state = 96;
+                this.match(LacLangParser.ADDRESS_LITERAL);
+                this.state = 97;
+                this.match(LacLangParser.T__1);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    instanceDeclaration() {
+        let _localctx = new InstanceDeclarationContext(this._ctx, this.state);
+        this.enterRule(_localctx, 20, LacLangParser.RULE_instanceDeclaration);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 99;
+                this.match(LacLangParser.T__11);
+                this.state = 100;
+                this.dataType();
+                this.state = 101;
+                this.match(LacLangParser.IDENTIFIER);
+                this.state = 102;
+                this.match(LacLangParser.T__12);
+                this.state = 103;
+                this.identifier_or_literal();
+                this.state = 104;
+                this.match(LacLangParser.T__13);
+                this.state = 105;
+                this.match(LacLangParser.T__6);
+                this.state = 107;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if ((_la & ~0x1f) === 0 &&
+                    ((1 << _la) &
+                        ((1 << LacLangParser.ADDRESS_LITERAL) |
+                            (1 << LacLangParser.BOOL_LITERAL) |
+                            (1 << LacLangParser.NUMBER_LITERAL) |
+                            (1 << LacLangParser.STRING_LITERAL) |
+                            (1 << LacLangParser.BYTES_LITERAL) |
+                            (1 << LacLangParser.IDENTIFIER))) !==
+                        0) {
+                    {
+                        this.state = 106;
+                        this.argumentsList();
+                    }
+                }
+                this.state = 109;
+                this.match(LacLangParser.T__7);
+                this.state = 116;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === LacLangParser.WITH_KEYWORD) {
+                    {
+                        this.state = 110;
+                        this.match(LacLangParser.WITH_KEYWORD);
+                        this.state = 111;
+                        this.match(LacLangParser.T__6);
+                        this.state = 113;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if ((_la & ~0x1f) === 0 &&
+                            ((1 << _la) &
+                                ((1 << LacLangParser.ADDRESS_LITERAL) |
+                                    (1 << LacLangParser.BOOL_LITERAL) |
+                                    (1 << LacLangParser.NUMBER_LITERAL) |
+                                    (1 << LacLangParser.STRING_LITERAL) |
+                                    (1 << LacLangParser.BYTES_LITERAL) |
+                                    (1 << LacLangParser.IDENTIFIER))) !==
+                                0) {
+                            {
+                                this.state = 112;
+                                this.constantsList();
+                            }
+                        }
+                        this.state = 115;
+                        this.match(LacLangParser.T__7);
+                    }
+                }
+                this.state = 118;
+                this.match(LacLangParser.T__1);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    evaluateStatement() {
+        let _localctx = new EvaluateStatementContext(this._ctx, this.state);
+        this.enterRule(_localctx, 22, LacLangParser.RULE_evaluateStatement);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 120;
+                this.match(LacLangParser.T__14);
+                this.state = 121;
+                this.match(LacLangParser.IDENTIFIER);
+                this.state = 122;
+                this.match(LacLangParser.T__1);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    dataType() {
+        let _localctx = new DataTypeContext(this._ctx, this.state);
+        this.enterRule(_localctx, 24, LacLangParser.RULE_dataType);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 124;
+                _la = this._input.LA(1);
+                if (!((_la & ~0x1f) === 0 &&
+                    ((1 << _la) &
+                        ((1 << LacLangParser.T__15) |
+                            (1 << LacLangParser.T__16) |
+                            (1 << LacLangParser.T__17) |
+                            (1 << LacLangParser.T__18) |
+                            (1 << LacLangParser.T__19))) !==
+                        0)) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    if (this._input.LA(1) === Token_1.Token.EOF) {
+                        this.matchedEOF = true;
+                    }
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    constantsList() {
+        let _localctx = new ConstantsListContext(this._ctx, this.state);
+        this.enterRule(_localctx, 26, LacLangParser.RULE_constantsList);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 126;
+                this.argumentsList();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    argumentsList() {
+        let _localctx = new ArgumentsListContext(this._ctx, this.state);
+        this.enterRule(_localctx, 28, LacLangParser.RULE_argumentsList);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 128;
+                this.identifier_or_literal();
+                this.state = 133;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === LacLangParser.T__20) {
+                    {
+                        {
+                            this.state = 129;
+                            this.match(LacLangParser.T__20);
+                            this.state = 130;
+                            this.identifier_or_literal();
+                        }
+                    }
+                    this.state = 135;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    identifier_or_literal() {
+        let _localctx = new Identifier_or_literalContext(this._ctx, this.state);
+        this.enterRule(_localctx, 30, LacLangParser.RULE_identifier_or_literal);
+        try {
+            this.state = 138;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case LacLangParser.IDENTIFIER:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 136;
+                        this.match(LacLangParser.IDENTIFIER);
+                    }
+                    break;
+                case LacLangParser.ADDRESS_LITERAL:
+                case LacLangParser.BOOL_LITERAL:
+                case LacLangParser.NUMBER_LITERAL:
+                case LacLangParser.STRING_LITERAL:
+                case LacLangParser.BYTES_LITERAL:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 137;
+                        this.literal();
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    literal() {
+        let _localctx = new LiteralContext(this._ctx, this.state);
+        this.enterRule(_localctx, 32, LacLangParser.RULE_literal);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 140;
+                _la = this._input.LA(1);
+                if (!((_la & ~0x1f) === 0 &&
+                    ((1 << _la) &
+                        ((1 << LacLangParser.ADDRESS_LITERAL) |
+                            (1 << LacLangParser.BOOL_LITERAL) |
+                            (1 << LacLangParser.NUMBER_LITERAL) |
+                            (1 << LacLangParser.STRING_LITERAL) |
+                            (1 << LacLangParser.BYTES_LITERAL))) !==
+                        0)) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    if (this._input.LA(1) === Token_1.Token.EOF) {
+                        this.matchedEOF = true;
+                    }
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    static _serializedATN = '\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03 \x91\x04\x02' +
+        '\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07' +
+        '\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04' +
+        '\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12\x03' +
+        '\x02\x07\x02&\n\x02\f\x02\x0E\x02)\v\x02\x03\x02\x07\x02,\n\x02\f\x02' +
+        '\x0E\x02/\v\x02\x03\x02\x07\x022\n\x02\f\x02\x0E\x025\v\x02\x03\x02\x03' +
+        '\x02\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x05\x03>\n\x03\x03\x04\x03' +
+        '\x04\x03\x04\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\x03\x06\x03' +
+        '\x07\x03\x07\x03\b\x03\b\x05\bN\n\b\x03\b\x03\b\x03\b\x03\b\x03\t\x03' +
+        '\t\x03\t\x03\t\x03\t\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\v\x03' +
+        '\v\x03\v\x03\v\x03\v\x03\v\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03' +
+        '\f\x05\fn\n\f\x03\f\x03\f\x03\f\x03\f\x05\ft\n\f\x03\f\x05\fw\n\f\x03' +
+        '\f\x03\f\x03\r\x03\r\x03\r\x03\r\x03\x0E\x03\x0E\x03\x0F\x03\x0F\x03\x10' +
+        '\x03\x10\x03\x10\x07\x10\x86\n\x10\f\x10\x0E\x10\x89\v\x10\x03\x11\x03' +
+        "\x11\x05\x11\x8D\n\x11\x03\x12\x03\x12\x03\x12\x05'-3\x02\x02\x13\x02" +
+        '\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02' +
+        '\x16\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02 \x02"\x02\x02\x04\x03\x02\x12' +
+        "\x16\x03\x02\x19\x1D\x02\x8C\x02'\x03\x02\x02\x02\x04=\x03\x02\x02\x02" +
+        '\x06?\x03\x02\x02\x02\bC\x03\x02\x02\x02\nG\x03\x02\x02\x02\fI\x03\x02' +
+        '\x02\x02\x0EK\x03\x02\x02\x02\x10S\x03\x02\x02\x02\x12X\x03\x02\x02\x02' +
+        '\x14_\x03\x02\x02\x02\x16e\x03\x02\x02\x02\x18z\x03\x02\x02\x02\x1A~\x03' +
+        '\x02\x02\x02\x1C\x80\x03\x02\x02\x02\x1E\x82\x03\x02\x02\x02 \x8C\x03' +
+        '\x02\x02\x02"\x8E\x03\x02\x02\x02$&\x05\x06\x04\x02%$\x03\x02\x02\x02' +
+        "&)\x03\x02\x02\x02'(\x03\x02\x02\x02'%\x03\x02\x02\x02(-\x03\x02\x02" +
+        "\x02)'\x03\x02\x02\x02*,\x05\b\x05\x02+*\x03\x02\x02\x02,/\x03\x02\x02" +
+        '\x02-.\x03\x02\x02\x02-+\x03\x02\x02\x02.3\x03\x02\x02\x02/-\x03\x02\x02' +
+        '\x0202\x05\x04\x03\x0210\x03\x02\x02\x0225\x03\x02\x02\x0234\x03\x02\x02' +
+        '\x0231\x03\x02\x02\x0246\x03\x02\x02\x0253\x03\x02\x02\x0267\x07\x02\x02' +
+        '\x037\x03\x03\x02\x02\x028>\x05\x0E\b\x029>\x05\x12\n\x02:>\x05\x14\v' +
+        '\x02;>\x05\x16\f\x02<>\x05\x18\r\x02=8\x03\x02\x02\x02=9\x03\x02\x02\x02' +
+        '=:\x03\x02\x02\x02=;\x03\x02\x02\x02=<\x03\x02\x02\x02>\x05\x03\x02\x02' +
+        '\x02?@\x07\x03\x02\x02@A\x07\x1C\x02\x02AB\x07\x04\x02\x02B\x07\x03\x02' +
+        '\x02\x02CD\x07\x05\x02\x02DE\x05\n\x06\x02EF\x07\x04\x02\x02F\t\x03\x02' +
+        '\x02\x02GH\x05\f\x07\x02H\v\x03\x02\x02\x02IJ\x07\x06\x02\x02J\r\x03\x02' +
+        '\x02\x02KM\x07\x07\x02\x02LN\x05\x10\t\x02ML\x03\x02\x02\x02MN\x03\x02' +
+        '\x02\x02NO\x03\x02\x02\x02OP\x05\x1A\x0E\x02PQ\x07\x1E\x02\x02QR\x07\x04' +
+        '\x02\x02R\x0F\x03\x02\x02\x02ST\x07\b\x02\x02TU\x07\t\x02\x02UV\x07\x1C' +
+        '\x02\x02VW\x07\n\x02\x02W\x11\x03\x02\x02\x02XY\x07\v\x02\x02YZ\x05\x1A' +
+        '\x0E\x02Z[\x07\x1E\x02\x02[\\\x07\f\x02\x02\\]\x05"\x12\x02]^\x07\x04' +
+        '\x02\x02^\x13\x03\x02\x02\x02_`\x07\r\x02\x02`a\x07\x1E\x02\x02ab\x07' +
+        '\f\x02\x02bc\x07\x19\x02\x02cd\x07\x04\x02\x02d\x15\x03\x02\x02\x02ef' +
+        '\x07\x0E\x02\x02fg\x05\x1A\x0E\x02gh\x07\x1E\x02\x02hi\x07\x0F\x02\x02' +
+        'ij\x05 \x11\x02jk\x07\x10\x02\x02km\x07\t\x02\x02ln\x05\x1E\x10\x02ml' +
+        '\x03\x02\x02\x02mn\x03\x02\x02\x02no\x03\x02\x02\x02ov\x07\n\x02\x02p' +
+        'q\x07\x18\x02\x02qs\x07\t\x02\x02rt\x05\x1C\x0F\x02sr\x03\x02\x02\x02' +
+        'st\x03\x02\x02\x02tu\x03\x02\x02\x02uw\x07\n\x02\x02vp\x03\x02\x02\x02' +
+        'vw\x03\x02\x02\x02wx\x03\x02\x02\x02xy\x07\x04\x02\x02y\x17\x03\x02\x02' +
+        '\x02z{\x07\x11\x02\x02{|\x07\x1E\x02\x02|}\x07\x04\x02\x02}\x19\x03\x02' +
+        '\x02\x02~\x7F\t\x02\x02\x02\x7F\x1B\x03\x02\x02\x02\x80\x81\x05\x1E\x10' +
+        '\x02\x81\x1D\x03\x02\x02\x02\x82\x87\x05 \x11\x02\x83\x84\x07\x17\x02' +
+        '\x02\x84\x86\x05 \x11\x02\x85\x83\x03\x02\x02\x02\x86\x89\x03\x02\x02' +
+        '\x02\x87\x85\x03\x02\x02\x02\x87\x88\x03\x02\x02\x02\x88\x1F\x03\x02\x02' +
+        '\x02\x89\x87\x03\x02\x02\x02\x8A\x8D\x07\x1E\x02\x02\x8B\x8D\x05"\x12' +
+        '\x02\x8C\x8A\x03\x02\x02\x02\x8C\x8B\x03\x02\x02\x02\x8D!\x03\x02\x02' +
+        "\x02\x8E\x8F\t\x03\x02\x02\x8F#\x03\x02\x02\x02\f'-3=Mmsv\x87\x8C";
+    static __ATN;
+    static get _ATN() {
+        if (!LacLangParser.__ATN) {
+            LacLangParser.__ATN = new ATNDeserializer_1.ATNDeserializer().deserialize(Utils.toCharArray(LacLangParser._serializedATN));
+        }
+        return LacLangParser.__ATN;
+    }
+}
+exports.LacLangParser = LacLangParser;
+class ProgramContext extends ParserRuleContext_1.ParserRuleContext {
+    EOF() {
+        return this.getToken(LacLangParser.EOF, 0);
+    }
+    importStatement(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ImportStatementContext);
+        }
+        else {
+            return this.getRuleContext(i, ImportStatementContext);
+        }
+    }
+    directive(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(DirectiveContext);
+        }
+        else {
+            return this.getRuleContext(i, DirectiveContext);
+        }
+    }
+    statement(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(StatementContext);
+        }
+        else {
+            return this.getRuleContext(i, StatementContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_program;
+    }
+    enterRule(listener) {
+        if (listener.enterProgram) {
+            listener.enterProgram(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitProgram) {
+            listener.exitProgram(this);
+        }
+    }
+}
+exports.ProgramContext = ProgramContext;
+class StatementContext extends ParserRuleContext_1.ParserRuleContext {
+    varDeclaration() {
+        return this.tryGetRuleContext(0, VarDeclarationContext);
+    }
+    constantDeclaration() {
+        return this.tryGetRuleContext(0, ConstantDeclarationContext);
+    }
+    artifactDeclaration() {
+        return this.tryGetRuleContext(0, ArtifactDeclarationContext);
+    }
+    instanceDeclaration() {
+        return this.tryGetRuleContext(0, InstanceDeclarationContext);
+    }
+    evaluateStatement() {
+        return this.tryGetRuleContext(0, EvaluateStatementContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_statement;
+    }
+    enterRule(listener) {
+        if (listener.enterStatement) {
+            listener.enterStatement(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitStatement) {
+            listener.exitStatement(this);
+        }
+    }
+}
+exports.StatementContext = StatementContext;
+class ImportStatementContext extends ParserRuleContext_1.ParserRuleContext {
+    STRING_LITERAL() {
+        return this.getToken(LacLangParser.STRING_LITERAL, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_importStatement;
+    }
+    enterRule(listener) {
+        if (listener.enterImportStatement) {
+            listener.enterImportStatement(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitImportStatement) {
+            listener.exitImportStatement(this);
+        }
+    }
+}
+exports.ImportStatementContext = ImportStatementContext;
+class DirectiveContext extends ParserRuleContext_1.ParserRuleContext {
+    directiveIndentifier() {
+        return this.getRuleContext(0, DirectiveIndentifierContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_directive;
+    }
+    enterRule(listener) {
+        if (listener.enterDirective) {
+            listener.enterDirective(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitDirective) {
+            listener.exitDirective(this);
+        }
+    }
+}
+exports.DirectiveContext = DirectiveContext;
+class DirectiveIndentifierContext extends ParserRuleContext_1.ParserRuleContext {
+    injectedOnlyDirective() {
+        return this.getRuleContext(0, InjectedOnlyDirectiveContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_directiveIndentifier;
+    }
+    enterRule(listener) {
+        if (listener.enterDirectiveIndentifier) {
+            listener.enterDirectiveIndentifier(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitDirectiveIndentifier) {
+            listener.exitDirectiveIndentifier(this);
+        }
+    }
+}
+exports.DirectiveIndentifierContext = DirectiveIndentifierContext;
+class InjectedOnlyDirectiveContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_injectedOnlyDirective;
+    }
+    enterRule(listener) {
+        if (listener.enterInjectedOnlyDirective) {
+            listener.enterInjectedOnlyDirective(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitInjectedOnlyDirective) {
+            listener.exitInjectedOnlyDirective(this);
+        }
+    }
+}
+exports.InjectedOnlyDirectiveContext = InjectedOnlyDirectiveContext;
+class VarDeclarationContext extends ParserRuleContext_1.ParserRuleContext {
+    dataType() {
+        return this.getRuleContext(0, DataTypeContext);
+    }
+    IDENTIFIER() {
+        return this.getToken(LacLangParser.IDENTIFIER, 0);
+    }
+    injectionModifier() {
+        return this.tryGetRuleContext(0, InjectionModifierContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_varDeclaration;
+    }
+    enterRule(listener) {
+        if (listener.enterVarDeclaration) {
+            listener.enterVarDeclaration(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitVarDeclaration) {
+            listener.exitVarDeclaration(this);
+        }
+    }
+}
+exports.VarDeclarationContext = VarDeclarationContext;
+class InjectionModifierContext extends ParserRuleContext_1.ParserRuleContext {
+    STRING_LITERAL() {
+        return this.getToken(LacLangParser.STRING_LITERAL, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_injectionModifier;
+    }
+    enterRule(listener) {
+        if (listener.enterInjectionModifier) {
+            listener.enterInjectionModifier(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitInjectionModifier) {
+            listener.exitInjectionModifier(this);
+        }
+    }
+}
+exports.InjectionModifierContext = InjectionModifierContext;
+class ConstantDeclarationContext extends ParserRuleContext_1.ParserRuleContext {
+    dataType() {
+        return this.getRuleContext(0, DataTypeContext);
+    }
+    IDENTIFIER() {
+        return this.getToken(LacLangParser.IDENTIFIER, 0);
+    }
+    literal() {
+        return this.getRuleContext(0, LiteralContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_constantDeclaration;
+    }
+    enterRule(listener) {
+        if (listener.enterConstantDeclaration) {
+            listener.enterConstantDeclaration(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitConstantDeclaration) {
+            listener.exitConstantDeclaration(this);
+        }
+    }
+}
+exports.ConstantDeclarationContext = ConstantDeclarationContext;
+class ArtifactDeclarationContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER() {
+        return this.getToken(LacLangParser.IDENTIFIER, 0);
+    }
+    ADDRESS_LITERAL() {
+        return this.getToken(LacLangParser.ADDRESS_LITERAL, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_artifactDeclaration;
+    }
+    enterRule(listener) {
+        if (listener.enterArtifactDeclaration) {
+            listener.enterArtifactDeclaration(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitArtifactDeclaration) {
+            listener.exitArtifactDeclaration(this);
+        }
+    }
+}
+exports.ArtifactDeclarationContext = ArtifactDeclarationContext;
+class InstanceDeclarationContext extends ParserRuleContext_1.ParserRuleContext {
+    dataType() {
+        return this.getRuleContext(0, DataTypeContext);
+    }
+    IDENTIFIER() {
+        return this.getToken(LacLangParser.IDENTIFIER, 0);
+    }
+    identifier_or_literal() {
+        return this.getRuleContext(0, Identifier_or_literalContext);
+    }
+    argumentsList() {
+        return this.tryGetRuleContext(0, ArgumentsListContext);
+    }
+    WITH_KEYWORD() {
+        return this.tryGetToken(LacLangParser.WITH_KEYWORD, 0);
+    }
+    constantsList() {
+        return this.tryGetRuleContext(0, ConstantsListContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_instanceDeclaration;
+    }
+    enterRule(listener) {
+        if (listener.enterInstanceDeclaration) {
+            listener.enterInstanceDeclaration(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitInstanceDeclaration) {
+            listener.exitInstanceDeclaration(this);
+        }
+    }
+}
+exports.InstanceDeclarationContext = InstanceDeclarationContext;
+class EvaluateStatementContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER() {
+        return this.getToken(LacLangParser.IDENTIFIER, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_evaluateStatement;
+    }
+    enterRule(listener) {
+        if (listener.enterEvaluateStatement) {
+            listener.enterEvaluateStatement(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitEvaluateStatement) {
+            listener.exitEvaluateStatement(this);
+        }
+    }
+}
+exports.EvaluateStatementContext = EvaluateStatementContext;
+class DataTypeContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_dataType;
+    }
+    enterRule(listener) {
+        if (listener.enterDataType) {
+            listener.enterDataType(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitDataType) {
+            listener.exitDataType(this);
+        }
+    }
+}
+exports.DataTypeContext = DataTypeContext;
+class ConstantsListContext extends ParserRuleContext_1.ParserRuleContext {
+    argumentsList() {
+        return this.getRuleContext(0, ArgumentsListContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_constantsList;
+    }
+    enterRule(listener) {
+        if (listener.enterConstantsList) {
+            listener.enterConstantsList(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitConstantsList) {
+            listener.exitConstantsList(this);
+        }
+    }
+}
+exports.ConstantsListContext = ConstantsListContext;
+class ArgumentsListContext extends ParserRuleContext_1.ParserRuleContext {
+    identifier_or_literal(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(Identifier_or_literalContext);
+        }
+        else {
+            return this.getRuleContext(i, Identifier_or_literalContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_argumentsList;
+    }
+    enterRule(listener) {
+        if (listener.enterArgumentsList) {
+            listener.enterArgumentsList(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitArgumentsList) {
+            listener.exitArgumentsList(this);
+        }
+    }
+}
+exports.ArgumentsListContext = ArgumentsListContext;
+class Identifier_or_literalContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER() {
+        return this.tryGetToken(LacLangParser.IDENTIFIER, 0);
+    }
+    literal() {
+        return this.tryGetRuleContext(0, LiteralContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_identifier_or_literal;
+    }
+    enterRule(listener) {
+        if (listener.enterIdentifier_or_literal) {
+            listener.enterIdentifier_or_literal(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitIdentifier_or_literal) {
+            listener.exitIdentifier_or_literal(this);
+        }
+    }
+}
+exports.Identifier_or_literalContext = Identifier_or_literalContext;
+class LiteralContext extends ParserRuleContext_1.ParserRuleContext {
+    BOOL_LITERAL() {
+        return this.tryGetToken(LacLangParser.BOOL_LITERAL, 0);
+    }
+    NUMBER_LITERAL() {
+        return this.tryGetToken(LacLangParser.NUMBER_LITERAL, 0);
+    }
+    STRING_LITERAL() {
+        return this.tryGetToken(LacLangParser.STRING_LITERAL, 0);
+    }
+    BYTES_LITERAL() {
+        return this.tryGetToken(LacLangParser.BYTES_LITERAL, 0);
+    }
+    ADDRESS_LITERAL() {
+        return this.tryGetToken(LacLangParser.ADDRESS_LITERAL, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    get ruleIndex() {
+        return LacLangParser.RULE_literal;
+    }
+    enterRule(listener) {
+        if (listener.enterLiteral) {
+            listener.enterLiteral(this);
+        }
+    }
+    exitRule(listener) {
+        if (listener.exitLiteral) {
+            listener.exitLiteral(this);
+        }
+    }
+}
+exports.LiteralContext = LiteralContext;
+//# sourceMappingURL=LacLangParser.js.map