blend-kit 1.0.1

package/dist/parser/blendbasic/src/grammar/BlendBasicParser.js

@@ -0,0 +1,747 @@
+"use strict";
+// Generated from src/grammar/BlendBasic.g4 by ANTLR 4.9.0-SNAPSHOT
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoModuleContext = exports.ReactModuleContext = exports.RnModuleContext = exports.ExpressModuleContext = exports.DataModuleContext = exports.ModuleContext = exports.SectionContext = exports.SectionsContext = exports.BlendBasicParser = void 0;
+const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
+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 ParserATNSimulator_1 = require("antlr4ts/atn/ParserATNSimulator");
+const RecognitionException_1 = require("antlr4ts/RecognitionException");
+const VocabularyImpl_1 = require("antlr4ts/VocabularyImpl");
+const Utils = __importStar(require("antlr4ts/misc/Utils"));
+class BlendBasicParser extends Parser_1.Parser {
+    // @Override
+    // @NotNull
+    get vocabulary() {
+        return BlendBasicParser.VOCABULARY;
+    }
+    // tslint:enable:no-trailing-whitespace
+    // @Override
+    get grammarFileName() { return "BlendBasic.g4"; }
+    // @Override
+    get ruleNames() { return BlendBasicParser.ruleNames; }
+    // @Override
+    get serializedATN() { return BlendBasicParser._serializedATN; }
+    createFailedPredicateException(predicate, message) {
+        return new FailedPredicateException_1.FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this._interp = new ParserATNSimulator_1.ParserATNSimulator(BlendBasicParser._ATN, this);
+    }
+    // @RuleVersion(0)
+    sections() {
+        let _localctx = new SectionsContext(this._ctx, this.state);
+        this.enterRule(_localctx, 0, BlendBasicParser.RULE_sections);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 17;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                do {
+                    {
+                        {
+                            this.state = 16;
+                            this.section();
+                        }
+                    }
+                    this.state = 19;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                } while (_la === BlendBasicParser.T__0);
+            }
+        }
+        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;
+    }
+    // @RuleVersion(0)
+    section() {
+        let _localctx = new SectionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 2, BlendBasicParser.RULE_section);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 21;
+                this.match(BlendBasicParser.T__0);
+                this.state = 22;
+                this.match(BlendBasicParser.IDENTIFIER);
+                this.state = 23;
+                this.match(BlendBasicParser.T__1);
+                this.state = 27;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << BlendBasicParser.T__3) | (1 << BlendBasicParser.T__5) | (1 << BlendBasicParser.T__6) | (1 << BlendBasicParser.T__7) | (1 << BlendBasicParser.T__8))) !== 0)) {
+                    {
+                        {
+                            this.state = 24;
+                            this.module();
+                        }
+                    }
+                    this.state = 29;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 30;
+                this.match(BlendBasicParser.T__2);
+            }
+        }
+        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;
+    }
+    // @RuleVersion(0)
+    module() {
+        let _localctx = new ModuleContext(this._ctx, this.state);
+        this.enterRule(_localctx, 4, BlendBasicParser.RULE_module);
+        try {
+            this.state = 37;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case BlendBasicParser.T__3:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 32;
+                        this.dataModule();
+                    }
+                    break;
+                case BlendBasicParser.T__5:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 33;
+                        this.expressModule();
+                    }
+                    break;
+                case BlendBasicParser.T__6:
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 34;
+                        this.rnModule();
+                    }
+                    break;
+                case BlendBasicParser.T__8:
+                    this.enterOuterAlt(_localctx, 4);
+                    {
+                        this.state = 35;
+                        this.mongoModule();
+                    }
+                    break;
+                case BlendBasicParser.T__7:
+                    this.enterOuterAlt(_localctx, 5);
+                    {
+                        this.state = 36;
+                        this.reactModule();
+                    }
+                    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;
+    }
+    // @RuleVersion(0)
+    dataModule() {
+        let _localctx = new DataModuleContext(this._ctx, this.state);
+        this.enterRule(_localctx, 6, BlendBasicParser.RULE_dataModule);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 39;
+                this.match(BlendBasicParser.T__3);
+                this.state = 40;
+                this.match(BlendBasicParser.IDENTIFIER);
+                this.state = 45;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendBasicParser.T__4) {
+                    {
+                        {
+                            this.state = 41;
+                            this.match(BlendBasicParser.T__4);
+                            this.state = 42;
+                            this.match(BlendBasicParser.IDENTIFIER);
+                        }
+                    }
+                    this.state = 47;
+                    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;
+    }
+    // @RuleVersion(0)
+    expressModule() {
+        let _localctx = new ExpressModuleContext(this._ctx, this.state);
+        this.enterRule(_localctx, 8, BlendBasicParser.RULE_expressModule);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 48;
+                this.match(BlendBasicParser.T__5);
+                this.state = 49;
+                this.match(BlendBasicParser.IDENTIFIER);
+                this.state = 54;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendBasicParser.T__4) {
+                    {
+                        {
+                            this.state = 50;
+                            this.match(BlendBasicParser.T__4);
+                            this.state = 51;
+                            this.match(BlendBasicParser.IDENTIFIER);
+                        }
+                    }
+                    this.state = 56;
+                    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;
+    }
+    // @RuleVersion(0)
+    rnModule() {
+        let _localctx = new RnModuleContext(this._ctx, this.state);
+        this.enterRule(_localctx, 10, BlendBasicParser.RULE_rnModule);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 57;
+                this.match(BlendBasicParser.T__6);
+                this.state = 58;
+                this.match(BlendBasicParser.IDENTIFIER);
+                this.state = 63;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendBasicParser.T__4) {
+                    {
+                        {
+                            this.state = 59;
+                            this.match(BlendBasicParser.T__4);
+                            this.state = 60;
+                            this.match(BlendBasicParser.IDENTIFIER);
+                        }
+                    }
+                    this.state = 65;
+                    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;
+    }
+    // @RuleVersion(0)
+    reactModule() {
+        let _localctx = new ReactModuleContext(this._ctx, this.state);
+        this.enterRule(_localctx, 12, BlendBasicParser.RULE_reactModule);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 66;
+                this.match(BlendBasicParser.T__7);
+                this.state = 67;
+                this.match(BlendBasicParser.IDENTIFIER);
+                this.state = 72;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendBasicParser.T__4) {
+                    {
+                        {
+                            this.state = 68;
+                            this.match(BlendBasicParser.T__4);
+                            this.state = 69;
+                            this.match(BlendBasicParser.IDENTIFIER);
+                        }
+                    }
+                    this.state = 74;
+                    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;
+    }
+    // @RuleVersion(0)
+    mongoModule() {
+        let _localctx = new MongoModuleContext(this._ctx, this.state);
+        this.enterRule(_localctx, 14, BlendBasicParser.RULE_mongoModule);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 75;
+                this.match(BlendBasicParser.T__8);
+                this.state = 76;
+                this.match(BlendBasicParser.IDENTIFIER);
+                this.state = 81;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendBasicParser.T__4) {
+                    {
+                        {
+                            this.state = 77;
+                            this.match(BlendBasicParser.T__4);
+                            this.state = 78;
+                            this.match(BlendBasicParser.IDENTIFIER);
+                        }
+                    }
+                    this.state = 83;
+                    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;
+    }
+    static get _ATN() {
+        if (!BlendBasicParser.__ATN) {
+            BlendBasicParser.__ATN = new ATNDeserializer_1.ATNDeserializer().deserialize(Utils.toCharArray(BlendBasicParser._serializedATN));
+        }
+        return BlendBasicParser.__ATN;
+    }
+}
+exports.BlendBasicParser = BlendBasicParser;
+BlendBasicParser.T__0 = 1;
+BlendBasicParser.T__1 = 2;
+BlendBasicParser.T__2 = 3;
+BlendBasicParser.T__3 = 4;
+BlendBasicParser.T__4 = 5;
+BlendBasicParser.T__5 = 6;
+BlendBasicParser.T__6 = 7;
+BlendBasicParser.T__7 = 8;
+BlendBasicParser.T__8 = 9;
+BlendBasicParser.IDENTIFIER = 10;
+BlendBasicParser.WS = 11;
+BlendBasicParser.RULE_sections = 0;
+BlendBasicParser.RULE_section = 1;
+BlendBasicParser.RULE_module = 2;
+BlendBasicParser.RULE_dataModule = 3;
+BlendBasicParser.RULE_expressModule = 4;
+BlendBasicParser.RULE_rnModule = 5;
+BlendBasicParser.RULE_reactModule = 6;
+BlendBasicParser.RULE_mongoModule = 7;
+// tslint:disable:no-trailing-whitespace
+BlendBasicParser.ruleNames = [
+    "sections", "section", "module", "dataModule", "expressModule", "rnModule",
+    "reactModule", "mongoModule",
+];
+BlendBasicParser._LITERAL_NAMES = [
+    undefined, "'section'", "'{'", "'}'", "'data-module'", "','", "'express-module'",
+    "'rn-module'", "'react-module'", "'mongo-module'",
+];
+BlendBasicParser._SYMBOLIC_NAMES = [
+    undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+    undefined, undefined, undefined, "IDENTIFIER", "WS",
+];
+BlendBasicParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(BlendBasicParser._LITERAL_NAMES, BlendBasicParser._SYMBOLIC_NAMES, []);
+BlendBasicParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\rW\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\x03\x02\x06\x02\x14\n\x02\r\x02\x0E\x02\x15\x03" +
+    "\x03\x03\x03\x03\x03\x03\x03\x07\x03\x1C\n\x03\f\x03\x0E\x03\x1F\v\x03" +
+    "\x03\x03\x03\x03\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04(\n\x04" +
+    "\x03\x05\x03\x05\x03\x05\x03\x05\x07\x05.\n\x05\f\x05\x0E\x051\v\x05\x03" +
+    "\x06\x03\x06\x03\x06\x03\x06\x07\x067\n\x06\f\x06\x0E\x06:\v\x06\x03\x07" +
+    "\x03\x07\x03\x07\x03\x07\x07\x07@\n\x07\f\x07\x0E\x07C\v\x07\x03\b\x03" +
+    "\b\x03\b\x03\b\x07\bI\n\b\f\b\x0E\bL\v\b\x03\t\x03\t\x03\t\x03\t\x07\t" +
+    "R\n\t\f\t\x0E\tU\v\t\x03\t\x02\x02\x02\n\x02\x02\x04\x02\x06\x02\b\x02" +
+    "\n\x02\f\x02\x0E\x02\x10\x02\x02\x02\x02Y\x02\x13\x03\x02\x02\x02\x04" +
+    "\x17\x03\x02\x02\x02\x06\'\x03\x02\x02\x02\b)\x03\x02\x02\x02\n2\x03\x02" +
+    "\x02\x02\f;\x03\x02\x02\x02\x0ED\x03\x02\x02\x02\x10M\x03\x02\x02\x02" +
+    "\x12\x14\x05\x04\x03\x02\x13\x12\x03\x02\x02\x02\x14\x15\x03\x02\x02\x02" +
+    "\x15\x13\x03\x02\x02\x02\x15\x16\x03\x02\x02\x02\x16\x03\x03\x02\x02\x02" +
+    "\x17\x18\x07\x03\x02\x02\x18\x19\x07\f\x02\x02\x19\x1D\x07\x04\x02\x02" +
+    "\x1A\x1C\x05\x06\x04\x02\x1B\x1A\x03\x02\x02\x02\x1C\x1F\x03\x02\x02\x02" +
+    "\x1D\x1B\x03\x02\x02\x02\x1D\x1E\x03\x02\x02\x02\x1E \x03\x02\x02\x02" +
+    "\x1F\x1D\x03\x02\x02\x02 !\x07\x05\x02\x02!\x05\x03\x02\x02\x02\"(\x05" +
+    "\b\x05\x02#(\x05\n\x06\x02$(\x05\f\x07\x02%(\x05\x10\t\x02&(\x05\x0E\b" +
+    "\x02\'\"\x03\x02\x02\x02\'#\x03\x02\x02\x02\'$\x03\x02\x02\x02\'%\x03" +
+    "\x02\x02\x02\'&\x03\x02\x02\x02(\x07\x03\x02\x02\x02)*\x07\x06\x02\x02" +
+    "*/\x07\f\x02\x02+,\x07\x07\x02\x02,.\x07\f\x02\x02-+\x03\x02\x02\x02." +
+    "1\x03\x02\x02\x02/-\x03\x02\x02\x02/0\x03\x02\x02\x020\t\x03\x02\x02\x02" +
+    "1/\x03\x02\x02\x0223\x07\b\x02\x0238\x07\f\x02\x0245\x07\x07\x02\x025" +
+    "7\x07\f\x02\x0264\x03\x02\x02\x027:\x03\x02\x02\x0286\x03\x02\x02\x02" +
+    "89\x03\x02\x02\x029\v\x03\x02\x02\x02:8\x03\x02\x02\x02;<\x07\t\x02\x02" +
+    "<A\x07\f\x02\x02=>\x07\x07\x02\x02>@\x07\f\x02\x02?=\x03\x02\x02\x02@" +
+    "C\x03\x02\x02\x02A?\x03\x02\x02\x02AB\x03\x02\x02\x02B\r\x03\x02\x02\x02" +
+    "CA\x03\x02\x02\x02DE\x07\n\x02\x02EJ\x07\f\x02\x02FG\x07\x07\x02\x02G" +
+    "I\x07\f\x02\x02HF\x03\x02\x02\x02IL\x03\x02\x02\x02JH\x03\x02\x02\x02" +
+    "JK\x03\x02\x02\x02K\x0F\x03\x02\x02\x02LJ\x03\x02\x02\x02MN\x07\v\x02" +
+    "\x02NS\x07\f\x02\x02OP\x07\x07\x02\x02PR\x07\f\x02\x02QO\x03\x02\x02\x02" +
+    "RU\x03\x02\x02\x02SQ\x03\x02\x02\x02ST\x03\x02\x02\x02T\x11\x03\x02\x02" +
+    "\x02US\x03\x02\x02\x02\n\x15\x1D\'/8AJS";
+class SectionsContext extends ParserRuleContext_1.ParserRuleContext {
+    section(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(SectionContext);
+        }
+        else {
+            return this.getRuleContext(i, SectionContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendBasicParser.RULE_sections; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterSections) {
+            listener.enterSections(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitSections) {
+            listener.exitSections(this);
+        }
+    }
+}
+exports.SectionsContext = SectionsContext;
+class SectionContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER() { return this.getToken(BlendBasicParser.IDENTIFIER, 0); }
+    module(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ModuleContext);
+        }
+        else {
+            return this.getRuleContext(i, ModuleContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendBasicParser.RULE_section; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterSection) {
+            listener.enterSection(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitSection) {
+            listener.exitSection(this);
+        }
+    }
+}
+exports.SectionContext = SectionContext;
+class ModuleContext extends ParserRuleContext_1.ParserRuleContext {
+    dataModule() {
+        return this.tryGetRuleContext(0, DataModuleContext);
+    }
+    expressModule() {
+        return this.tryGetRuleContext(0, ExpressModuleContext);
+    }
+    rnModule() {
+        return this.tryGetRuleContext(0, RnModuleContext);
+    }
+    mongoModule() {
+        return this.tryGetRuleContext(0, MongoModuleContext);
+    }
+    reactModule() {
+        return this.tryGetRuleContext(0, ReactModuleContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendBasicParser.RULE_module; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterModule) {
+            listener.enterModule(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitModule) {
+            listener.exitModule(this);
+        }
+    }
+}
+exports.ModuleContext = ModuleContext;
+class DataModuleContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendBasicParser.IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendBasicParser.IDENTIFIER, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendBasicParser.RULE_dataModule; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterDataModule) {
+            listener.enterDataModule(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitDataModule) {
+            listener.exitDataModule(this);
+        }
+    }
+}
+exports.DataModuleContext = DataModuleContext;
+class ExpressModuleContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendBasicParser.IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendBasicParser.IDENTIFIER, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendBasicParser.RULE_expressModule; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterExpressModule) {
+            listener.enterExpressModule(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitExpressModule) {
+            listener.exitExpressModule(this);
+        }
+    }
+}
+exports.ExpressModuleContext = ExpressModuleContext;
+class RnModuleContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendBasicParser.IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendBasicParser.IDENTIFIER, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendBasicParser.RULE_rnModule; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterRnModule) {
+            listener.enterRnModule(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitRnModule) {
+            listener.exitRnModule(this);
+        }
+    }
+}
+exports.RnModuleContext = RnModuleContext;
+class ReactModuleContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendBasicParser.IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendBasicParser.IDENTIFIER, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendBasicParser.RULE_reactModule; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterReactModule) {
+            listener.enterReactModule(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitReactModule) {
+            listener.exitReactModule(this);
+        }
+    }
+}
+exports.ReactModuleContext = ReactModuleContext;
+class MongoModuleContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendBasicParser.IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendBasicParser.IDENTIFIER, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendBasicParser.RULE_mongoModule; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterMongoModule) {
+            listener.enterMongoModule(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitMongoModule) {
+            listener.exitMongoModule(this);
+        }
+    }
+}
+exports.MongoModuleContext = MongoModuleContext;