blend-r 1.1.6

package/dist/parser/blendRnBasic/src/grammar/BlendRnBasicParser.js

@@ -0,0 +1,1224 @@
+"use strict";
+// Generated from src/grammar/BlendRnBasic.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.PrimitiveTypeContext = exports.TypeContext = exports.FieldContext = exports.ParamsDefinitionContext = exports.ParamsSectionContext = exports.PageDefinitionContext = exports.LayoutDefinitionContext = exports.ComponentDefenitionContext = exports.ScreenDefenitionContext = exports.ProgramContext = exports.ApiModuleContext = exports.DataModuleContext = exports.ModuleContext = exports.SectionsContext = exports.BlendRnBasicParser = 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 Token_1 = require("antlr4ts/Token");
+const VocabularyImpl_1 = require("antlr4ts/VocabularyImpl");
+const Utils = __importStar(require("antlr4ts/misc/Utils"));
+class BlendRnBasicParser extends Parser_1.Parser {
+    // @Override
+    // @NotNull
+    get vocabulary() {
+        return BlendRnBasicParser.VOCABULARY;
+    }
+    // tslint:enable:no-trailing-whitespace
+    // @Override
+    get grammarFileName() { return "BlendRnBasic.g4"; }
+    // @Override
+    get ruleNames() { return BlendRnBasicParser.ruleNames; }
+    // @Override
+    get serializedATN() { return BlendRnBasicParser._serializedATN; }
+    createFailedPredicateException(predicate, message) {
+        return new FailedPredicateException_1.FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this._interp = new ParserATNSimulator_1.ParserATNSimulator(BlendRnBasicParser._ATN, this);
+    }
+    // @RuleVersion(0)
+    sections() {
+        let _localctx = new SectionsContext(this._ctx, this.state);
+        this.enterRule(_localctx, 0, BlendRnBasicParser.RULE_sections);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 31;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__0 || _la === BlendRnBasicParser.T__2) {
+                    {
+                        {
+                            this.state = 28;
+                            this.module();
+                        }
+                    }
+                    this.state = 33;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 34;
+                this.program();
+            }
+        }
+        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, 2, BlendRnBasicParser.RULE_module);
+        try {
+            this.state = 38;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case BlendRnBasicParser.T__0:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 36;
+                        this.dataModule();
+                    }
+                    break;
+                case BlendRnBasicParser.T__2:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 37;
+                        this.apiModule();
+                    }
+                    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, 4, BlendRnBasicParser.RULE_dataModule);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 40;
+                this.match(BlendRnBasicParser.T__0);
+                this.state = 41;
+                this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                this.state = 46;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__1) {
+                    {
+                        {
+                            this.state = 42;
+                            this.match(BlendRnBasicParser.T__1);
+                            this.state = 43;
+                            this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                        }
+                    }
+                    this.state = 48;
+                    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)
+    apiModule() {
+        let _localctx = new ApiModuleContext(this._ctx, this.state);
+        this.enterRule(_localctx, 6, BlendRnBasicParser.RULE_apiModule);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 49;
+                this.match(BlendRnBasicParser.T__2);
+                this.state = 50;
+                this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                this.state = 55;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__1) {
+                    {
+                        {
+                            this.state = 51;
+                            this.match(BlendRnBasicParser.T__1);
+                            this.state = 52;
+                            this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                        }
+                    }
+                    this.state = 57;
+                    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)
+    program() {
+        let _localctx = new ProgramContext(this._ctx, this.state);
+        this.enterRule(_localctx, 8, BlendRnBasicParser.RULE_program);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 61;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__5) {
+                    {
+                        {
+                            this.state = 58;
+                            this.componentDefenition();
+                        }
+                    }
+                    this.state = 63;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 67;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__3) {
+                    {
+                        {
+                            this.state = 64;
+                            this.screenDefenition();
+                        }
+                    }
+                    this.state = 69;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 73;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__6) {
+                    {
+                        {
+                            this.state = 70;
+                            this.layoutDefinition();
+                        }
+                    }
+                    this.state = 75;
+                    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)
+    screenDefenition() {
+        let _localctx = new ScreenDefenitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 10, BlendRnBasicParser.RULE_screenDefenition);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 76;
+                this.match(BlendRnBasicParser.T__3);
+                this.state = 77;
+                this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                this.state = 82;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__1) {
+                    {
+                        {
+                            this.state = 78;
+                            this.match(BlendRnBasicParser.T__1);
+                            this.state = 79;
+                            this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                        }
+                    }
+                    this.state = 84;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 85;
+                this.match(BlendRnBasicParser.T__4);
+                this.state = 86;
+                this.match(BlendRnBasicParser.PATH_IDENTIFIER);
+            }
+        }
+        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)
+    componentDefenition() {
+        let _localctx = new ComponentDefenitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 12, BlendRnBasicParser.RULE_componentDefenition);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 88;
+                this.match(BlendRnBasicParser.T__5);
+                this.state = 89;
+                this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                this.state = 94;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__1) {
+                    {
+                        {
+                            this.state = 90;
+                            this.match(BlendRnBasicParser.T__1);
+                            this.state = 91;
+                            this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                        }
+                    }
+                    this.state = 96;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 97;
+                this.match(BlendRnBasicParser.T__4);
+                this.state = 98;
+                this.match(BlendRnBasicParser.PATH_IDENTIFIER);
+            }
+        }
+        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)
+    layoutDefinition() {
+        let _localctx = new LayoutDefinitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 14, BlendRnBasicParser.RULE_layoutDefinition);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 100;
+                this.match(BlendRnBasicParser.T__6);
+                this.state = 101;
+                this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                this.state = 103;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === BlendRnBasicParser.T__8) {
+                    {
+                        this.state = 102;
+                        this.paramsSection();
+                    }
+                }
+                this.state = 105;
+                this.match(BlendRnBasicParser.T__7);
+                this.state = 106;
+                this.match(BlendRnBasicParser.T__8);
+                this.state = 107;
+                this.match(BlendRnBasicParser.LAYOUT_TYPE);
+                this.state = 108;
+                this.match(BlendRnBasicParser.T__9);
+                this.state = 109;
+                this.match(BlendRnBasicParser.T__10);
+                this.state = 114;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__6 || _la === BlendRnBasicParser.T__12) {
+                    {
+                        this.state = 112;
+                        this._errHandler.sync(this);
+                        switch (this._input.LA(1)) {
+                            case BlendRnBasicParser.T__12:
+                                {
+                                    this.state = 110;
+                                    this.pageDefinition();
+                                }
+                                break;
+                            case BlendRnBasicParser.T__6:
+                                {
+                                    this.state = 111;
+                                    this.layoutDefinition();
+                                }
+                                break;
+                            default:
+                                throw new NoViableAltException_1.NoViableAltException(this);
+                        }
+                    }
+                    this.state = 116;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 117;
+                this.match(BlendRnBasicParser.T__11);
+            }
+        }
+        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)
+    pageDefinition() {
+        let _localctx = new PageDefinitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 16, BlendRnBasicParser.RULE_pageDefinition);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 119;
+                this.match(BlendRnBasicParser.T__12);
+                this.state = 120;
+                this.match(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+                this.state = 122;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === BlendRnBasicParser.T__8) {
+                    {
+                        this.state = 121;
+                        this.paramsSection();
+                    }
+                }
+            }
+        }
+        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)
+    paramsSection() {
+        let _localctx = new ParamsSectionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 18, BlendRnBasicParser.RULE_paramsSection);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 124;
+                this.match(BlendRnBasicParser.T__8);
+                this.state = 125;
+                this.paramsDefinition();
+                this.state = 126;
+                this.match(BlendRnBasicParser.T__9);
+            }
+        }
+        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)
+    paramsDefinition() {
+        let _localctx = new ParamsDefinitionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 20, BlendRnBasicParser.RULE_paramsDefinition);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 128;
+                this.field();
+                this.state = 133;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === BlendRnBasicParser.T__1) {
+                    {
+                        {
+                            this.state = 129;
+                            this.match(BlendRnBasicParser.T__1);
+                            this.state = 130;
+                            this.field();
+                        }
+                    }
+                    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;
+    }
+    // @RuleVersion(0)
+    field() {
+        let _localctx = new FieldContext(this._ctx, this.state);
+        this.enterRule(_localctx, 22, BlendRnBasicParser.RULE_field);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 136;
+                this.match(BlendRnBasicParser.IDENTIFIER);
+                this.state = 137;
+                this.match(BlendRnBasicParser.T__13);
+                this.state = 138;
+                this.type();
+            }
+        }
+        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)
+    type() {
+        let _localctx = new TypeContext(this._ctx, this.state);
+        this.enterRule(_localctx, 24, BlendRnBasicParser.RULE_type);
+        try {
+            this.state = 144;
+            this._errHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this._input, 14, this._ctx)) {
+                case 1:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 140;
+                        this.primitiveType();
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 141;
+                        this.primitiveType();
+                        this.state = 142;
+                        this.match(BlendRnBasicParser.T__14);
+                    }
+                    break;
+            }
+        }
+        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)
+    primitiveType() {
+        let _localctx = new PrimitiveTypeContext(this._ctx, this.state);
+        this.enterRule(_localctx, 26, BlendRnBasicParser.RULE_primitiveType);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 146;
+                _la = this._input.LA(1);
+                if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << BlendRnBasicParser.T__15) | (1 << BlendRnBasicParser.T__16) | (1 << BlendRnBasicParser.T__17) | (1 << BlendRnBasicParser.T__18) | (1 << BlendRnBasicParser.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;
+    }
+    static get _ATN() {
+        if (!BlendRnBasicParser.__ATN) {
+            BlendRnBasicParser.__ATN = new ATNDeserializer_1.ATNDeserializer().deserialize(Utils.toCharArray(BlendRnBasicParser._serializedATN));
+        }
+        return BlendRnBasicParser.__ATN;
+    }
+}
+exports.BlendRnBasicParser = BlendRnBasicParser;
+BlendRnBasicParser.T__0 = 1;
+BlendRnBasicParser.T__1 = 2;
+BlendRnBasicParser.T__2 = 3;
+BlendRnBasicParser.T__3 = 4;
+BlendRnBasicParser.T__4 = 5;
+BlendRnBasicParser.T__5 = 6;
+BlendRnBasicParser.T__6 = 7;
+BlendRnBasicParser.T__7 = 8;
+BlendRnBasicParser.T__8 = 9;
+BlendRnBasicParser.T__9 = 10;
+BlendRnBasicParser.T__10 = 11;
+BlendRnBasicParser.T__11 = 12;
+BlendRnBasicParser.T__12 = 13;
+BlendRnBasicParser.T__13 = 14;
+BlendRnBasicParser.T__14 = 15;
+BlendRnBasicParser.T__15 = 16;
+BlendRnBasicParser.T__16 = 17;
+BlendRnBasicParser.T__17 = 18;
+BlendRnBasicParser.T__18 = 19;
+BlendRnBasicParser.T__19 = 20;
+BlendRnBasicParser.LAYOUT_TYPE = 21;
+BlendRnBasicParser.PATH_IDENTIFIER = 22;
+BlendRnBasicParser.IDENTIFIER = 23;
+BlendRnBasicParser.CAPITAL_IDENTIFIER = 24;
+BlendRnBasicParser.WS = 25;
+BlendRnBasicParser.RULE_sections = 0;
+BlendRnBasicParser.RULE_module = 1;
+BlendRnBasicParser.RULE_dataModule = 2;
+BlendRnBasicParser.RULE_apiModule = 3;
+BlendRnBasicParser.RULE_program = 4;
+BlendRnBasicParser.RULE_screenDefenition = 5;
+BlendRnBasicParser.RULE_componentDefenition = 6;
+BlendRnBasicParser.RULE_layoutDefinition = 7;
+BlendRnBasicParser.RULE_pageDefinition = 8;
+BlendRnBasicParser.RULE_paramsSection = 9;
+BlendRnBasicParser.RULE_paramsDefinition = 10;
+BlendRnBasicParser.RULE_field = 11;
+BlendRnBasicParser.RULE_type = 12;
+BlendRnBasicParser.RULE_primitiveType = 13;
+// tslint:disable:no-trailing-whitespace
+BlendRnBasicParser.ruleNames = [
+    "sections", "module", "dataModule", "apiModule", "program", "screenDefenition",
+    "componentDefenition", "layoutDefinition", "pageDefinition", "paramsSection",
+    "paramsDefinition", "field", "type", "primitiveType",
+];
+BlendRnBasicParser._LITERAL_NAMES = [
+    undefined, "'data-module'", "','", "'api-module'", "'screen'", "'under'",
+    "'component'", "'layout'", "'type'", "'('", "')'", "'{'", "'}'", "'page'",
+    "':'", "'?'", "'string'", "'number'", "'boolean'", "'any'", "'object'",
+];
+BlendRnBasicParser._SYMBOLIC_NAMES = [
+    undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+    undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+    undefined, undefined, undefined, undefined, undefined, undefined, undefined,
+    "LAYOUT_TYPE", "PATH_IDENTIFIER", "IDENTIFIER", "CAPITAL_IDENTIFIER",
+    "WS",
+];
+BlendRnBasicParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(BlendRnBasicParser._LITERAL_NAMES, BlendRnBasicParser._SYMBOLIC_NAMES, []);
+BlendRnBasicParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x1B\x97\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\x03\x02\x07\x02 \n\x02\f\x02\x0E\x02#\v\x02\x03" +
+    "\x02\x03\x02\x03\x03\x03\x03\x05\x03)\n\x03\x03\x04\x03\x04\x03\x04\x03" +
+    "\x04\x07\x04/\n\x04\f\x04\x0E\x042\v\x04\x03\x05\x03\x05\x03\x05\x03\x05" +
+    "\x07\x058\n\x05\f\x05\x0E\x05;\v\x05\x03\x06\x07\x06>\n\x06\f\x06\x0E" +
+    "\x06A\v\x06\x03\x06\x07\x06D\n\x06\f\x06\x0E\x06G\v\x06\x03\x06\x07\x06" +
+    "J\n\x06\f\x06\x0E\x06M\v\x06\x03\x07\x03\x07\x03\x07\x03\x07\x07\x07S" +
+    "\n\x07\f\x07\x0E\x07V\v\x07\x03\x07\x03\x07\x03\x07\x03\b\x03\b\x03\b" +
+    "\x03\b\x07\b_\n\b\f\b\x0E\bb\v\b\x03\b\x03\b\x03\b\x03\t\x03\t\x03\t\x05" +
+    "\tj\n\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x07\ts\n\t\f\t\x0E\t" +
+    "v\v\t\x03\t\x03\t\x03\n\x03\n\x03\n\x05\n}\n\n\x03\v\x03\v\x03\v\x03\v" +
+    "\x03\f\x03\f\x03\f\x07\f\x86\n\f\f\f\x0E\f\x89\v\f\x03\r\x03\r\x03\r\x03" +
+    "\r\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x05\x0E\x93\n\x0E\x03\x0F\x03\x0F\x03" +
+    "\x0F\x02\x02\x02\x10\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\x02\x03\x03\x02" +
+    "\x12\x16\x02\x97\x02!\x03\x02\x02\x02\x04(\x03\x02\x02\x02\x06*\x03\x02" +
+    "\x02\x02\b3\x03\x02\x02\x02\n?\x03\x02\x02\x02\fN\x03\x02\x02\x02\x0E" +
+    "Z\x03\x02\x02\x02\x10f\x03\x02\x02\x02\x12y\x03\x02\x02\x02\x14~\x03\x02" +
+    "\x02\x02\x16\x82\x03\x02\x02\x02\x18\x8A\x03\x02\x02\x02\x1A\x92\x03\x02" +
+    "\x02\x02\x1C\x94\x03\x02\x02\x02\x1E \x05\x04\x03\x02\x1F\x1E\x03\x02" +
+    "\x02\x02 #\x03\x02\x02\x02!\x1F\x03\x02\x02\x02!\"\x03\x02\x02\x02\"$" +
+    "\x03\x02\x02\x02#!\x03\x02\x02\x02$%\x05\n\x06\x02%\x03\x03\x02\x02\x02" +
+    "&)\x05\x06\x04\x02\')\x05\b\x05\x02(&\x03\x02\x02\x02(\'\x03\x02\x02\x02" +
+    ")\x05\x03\x02\x02\x02*+\x07\x03\x02\x02+0\x07\x1A\x02\x02,-\x07\x04\x02" +
+    "\x02-/\x07\x1A\x02\x02.,\x03\x02\x02\x02/2\x03\x02\x02\x020.\x03\x02\x02" +
+    "\x0201\x03\x02\x02\x021\x07\x03\x02\x02\x0220\x03\x02\x02\x0234\x07\x05" +
+    "\x02\x0249\x07\x1A\x02\x0256\x07\x04\x02\x0268\x07\x1A\x02\x0275\x03\x02" +
+    "\x02\x028;\x03\x02\x02\x0297\x03\x02\x02\x029:\x03\x02\x02\x02:\t\x03" +
+    "\x02\x02\x02;9\x03\x02\x02\x02<>\x05\x0E\b\x02=<\x03\x02\x02\x02>A\x03" +
+    "\x02\x02\x02?=\x03\x02\x02\x02?@\x03\x02\x02\x02@E\x03\x02\x02\x02A?\x03" +
+    "\x02\x02\x02BD\x05\f\x07\x02CB\x03\x02\x02\x02DG\x03\x02\x02\x02EC\x03" +
+    "\x02\x02\x02EF\x03\x02\x02\x02FK\x03\x02\x02\x02GE\x03\x02\x02\x02HJ\x05" +
+    "\x10\t\x02IH\x03\x02\x02\x02JM\x03\x02\x02\x02KI\x03\x02\x02\x02KL\x03" +
+    "\x02\x02\x02L\v\x03\x02\x02\x02MK\x03\x02\x02\x02NO\x07\x06\x02\x02OT" +
+    "\x07\x1A\x02\x02PQ\x07\x04\x02\x02QS\x07\x1A\x02\x02RP\x03\x02\x02\x02" +
+    "SV\x03\x02\x02\x02TR\x03\x02\x02\x02TU\x03\x02\x02\x02UW\x03\x02\x02\x02" +
+    "VT\x03\x02\x02\x02WX\x07\x07\x02\x02XY\x07\x18\x02\x02Y\r\x03\x02\x02" +
+    "\x02Z[\x07\b\x02\x02[`\x07\x1A\x02\x02\\]\x07\x04\x02\x02]_\x07\x1A\x02" +
+    "\x02^\\\x03\x02\x02\x02_b\x03\x02\x02\x02`^\x03\x02\x02\x02`a\x03\x02" +
+    "\x02\x02ac\x03\x02\x02\x02b`\x03\x02\x02\x02cd\x07\x07\x02\x02de\x07\x18" +
+    "\x02\x02e\x0F\x03\x02\x02\x02fg\x07\t\x02\x02gi\x07\x1A\x02\x02hj\x05" +
+    "\x14\v\x02ih\x03\x02\x02\x02ij\x03\x02\x02\x02jk\x03\x02\x02\x02kl\x07" +
+    "\n\x02\x02lm\x07\v\x02\x02mn\x07\x17\x02\x02no\x07\f\x02\x02ot\x07\r\x02" +
+    "\x02ps\x05\x12\n\x02qs\x05\x10\t\x02rp\x03\x02\x02\x02rq\x03\x02\x02\x02" +
+    "sv\x03\x02\x02\x02tr\x03\x02\x02\x02tu\x03\x02\x02\x02uw\x03\x02\x02\x02" +
+    "vt\x03\x02\x02\x02wx\x07\x0E\x02\x02x\x11\x03\x02\x02\x02yz\x07\x0F\x02" +
+    "\x02z|\x07\x1A\x02\x02{}\x05\x14\v\x02|{\x03\x02\x02\x02|}\x03\x02\x02" +
+    "\x02}\x13\x03\x02\x02\x02~\x7F\x07\v\x02\x02\x7F\x80\x05\x16\f\x02\x80" +
+    "\x81\x07\f\x02\x02\x81\x15\x03\x02\x02\x02\x82\x87\x05\x18\r\x02\x83\x84" +
+    "\x07\x04\x02\x02\x84\x86\x05\x18\r\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\x17" +
+    "\x03\x02\x02\x02\x89\x87\x03\x02\x02\x02\x8A\x8B\x07\x19\x02\x02\x8B\x8C" +
+    "\x07\x10\x02\x02\x8C\x8D\x05\x1A\x0E\x02\x8D\x19\x03\x02\x02\x02\x8E\x93" +
+    "\x05\x1C\x0F\x02\x8F\x90\x05\x1C\x0F\x02\x90\x91\x07\x11\x02\x02\x91\x93" +
+    "\x03\x02\x02\x02\x92\x8E\x03\x02\x02\x02\x92\x8F\x03\x02\x02\x02\x93\x1B" +
+    "\x03\x02\x02\x02\x94\x95\t\x02\x02\x02\x95\x1D\x03\x02\x02\x02\x11!(0" +
+    "9?EKT`irt|\x87\x92";
+class SectionsContext extends ParserRuleContext_1.ParserRuleContext {
+    program() {
+        return this.getRuleContext(0, ProgramContext);
+    }
+    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 BlendRnBasicParser.RULE_sections; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterSections) {
+            listener.enterSections(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitSections) {
+            listener.exitSections(this);
+        }
+    }
+}
+exports.SectionsContext = SectionsContext;
+class ModuleContext extends ParserRuleContext_1.ParserRuleContext {
+    dataModule() {
+        return this.tryGetRuleContext(0, DataModuleContext);
+    }
+    apiModule() {
+        return this.tryGetRuleContext(0, ApiModuleContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.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 {
+    CAPITAL_IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendRnBasicParser.CAPITAL_IDENTIFIER, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_dataModule; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterDataModule) {
+            listener.enterDataModule(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitDataModule) {
+            listener.exitDataModule(this);
+        }
+    }
+}
+exports.DataModuleContext = DataModuleContext;
+class ApiModuleContext extends ParserRuleContext_1.ParserRuleContext {
+    CAPITAL_IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendRnBasicParser.CAPITAL_IDENTIFIER, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_apiModule; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterApiModule) {
+            listener.enterApiModule(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitApiModule) {
+            listener.exitApiModule(this);
+        }
+    }
+}
+exports.ApiModuleContext = ApiModuleContext;
+class ProgramContext extends ParserRuleContext_1.ParserRuleContext {
+    componentDefenition(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ComponentDefenitionContext);
+        }
+        else {
+            return this.getRuleContext(i, ComponentDefenitionContext);
+        }
+    }
+    screenDefenition(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ScreenDefenitionContext);
+        }
+        else {
+            return this.getRuleContext(i, ScreenDefenitionContext);
+        }
+    }
+    layoutDefinition(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(LayoutDefinitionContext);
+        }
+        else {
+            return this.getRuleContext(i, LayoutDefinitionContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_program; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterProgram) {
+            listener.enterProgram(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitProgram) {
+            listener.exitProgram(this);
+        }
+    }
+}
+exports.ProgramContext = ProgramContext;
+class ScreenDefenitionContext extends ParserRuleContext_1.ParserRuleContext {
+    CAPITAL_IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendRnBasicParser.CAPITAL_IDENTIFIER, i);
+        }
+    }
+    PATH_IDENTIFIER() { return this.getToken(BlendRnBasicParser.PATH_IDENTIFIER, 0); }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_screenDefenition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterScreenDefenition) {
+            listener.enterScreenDefenition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitScreenDefenition) {
+            listener.exitScreenDefenition(this);
+        }
+    }
+}
+exports.ScreenDefenitionContext = ScreenDefenitionContext;
+class ComponentDefenitionContext extends ParserRuleContext_1.ParserRuleContext {
+    CAPITAL_IDENTIFIER(i) {
+        if (i === undefined) {
+            return this.getTokens(BlendRnBasicParser.CAPITAL_IDENTIFIER);
+        }
+        else {
+            return this.getToken(BlendRnBasicParser.CAPITAL_IDENTIFIER, i);
+        }
+    }
+    PATH_IDENTIFIER() { return this.getToken(BlendRnBasicParser.PATH_IDENTIFIER, 0); }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_componentDefenition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterComponentDefenition) {
+            listener.enterComponentDefenition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitComponentDefenition) {
+            listener.exitComponentDefenition(this);
+        }
+    }
+}
+exports.ComponentDefenitionContext = ComponentDefenitionContext;
+class LayoutDefinitionContext extends ParserRuleContext_1.ParserRuleContext {
+    CAPITAL_IDENTIFIER() { return this.getToken(BlendRnBasicParser.CAPITAL_IDENTIFIER, 0); }
+    LAYOUT_TYPE() { return this.getToken(BlendRnBasicParser.LAYOUT_TYPE, 0); }
+    paramsSection() {
+        return this.tryGetRuleContext(0, ParamsSectionContext);
+    }
+    pageDefinition(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(PageDefinitionContext);
+        }
+        else {
+            return this.getRuleContext(i, PageDefinitionContext);
+        }
+    }
+    layoutDefinition(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(LayoutDefinitionContext);
+        }
+        else {
+            return this.getRuleContext(i, LayoutDefinitionContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_layoutDefinition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterLayoutDefinition) {
+            listener.enterLayoutDefinition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitLayoutDefinition) {
+            listener.exitLayoutDefinition(this);
+        }
+    }
+}
+exports.LayoutDefinitionContext = LayoutDefinitionContext;
+class PageDefinitionContext extends ParserRuleContext_1.ParserRuleContext {
+    CAPITAL_IDENTIFIER() { return this.getToken(BlendRnBasicParser.CAPITAL_IDENTIFIER, 0); }
+    paramsSection() {
+        return this.tryGetRuleContext(0, ParamsSectionContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_pageDefinition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterPageDefinition) {
+            listener.enterPageDefinition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitPageDefinition) {
+            listener.exitPageDefinition(this);
+        }
+    }
+}
+exports.PageDefinitionContext = PageDefinitionContext;
+class ParamsSectionContext extends ParserRuleContext_1.ParserRuleContext {
+    paramsDefinition() {
+        return this.getRuleContext(0, ParamsDefinitionContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_paramsSection; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterParamsSection) {
+            listener.enterParamsSection(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitParamsSection) {
+            listener.exitParamsSection(this);
+        }
+    }
+}
+exports.ParamsSectionContext = ParamsSectionContext;
+class ParamsDefinitionContext extends ParserRuleContext_1.ParserRuleContext {
+    field(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(FieldContext);
+        }
+        else {
+            return this.getRuleContext(i, FieldContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_paramsDefinition; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterParamsDefinition) {
+            listener.enterParamsDefinition(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitParamsDefinition) {
+            listener.exitParamsDefinition(this);
+        }
+    }
+}
+exports.ParamsDefinitionContext = ParamsDefinitionContext;
+class FieldContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER() { return this.getToken(BlendRnBasicParser.IDENTIFIER, 0); }
+    type() {
+        return this.getRuleContext(0, TypeContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_field; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterField) {
+            listener.enterField(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitField) {
+            listener.exitField(this);
+        }
+    }
+}
+exports.FieldContext = FieldContext;
+class TypeContext extends ParserRuleContext_1.ParserRuleContext {
+    primitiveType() {
+        return this.getRuleContext(0, PrimitiveTypeContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_type; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterType) {
+            listener.enterType(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitType) {
+            listener.exitType(this);
+        }
+    }
+}
+exports.TypeContext = TypeContext;
+class PrimitiveTypeContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return BlendRnBasicParser.RULE_primitiveType; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterPrimitiveType) {
+            listener.enterPrimitiveType(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitPrimitiveType) {
+            listener.exitPrimitiveType(this);
+        }
+    }
+}
+exports.PrimitiveTypeContext = PrimitiveTypeContext;