yini-parser 1.0.0-alpha.1

package/dist/src/grammar/YiniParser.js

@@ -0,0 +1,2106 @@
+"use strict";
+// Generated from grammar/v1.0.0-beta.7x/YiniParser.g4 by ANTLR 4.13.2
+// noinspection ES6UnusedImports,JSUnusedGlobalSymbols,JSUnusedLocalSymbols
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Boolean_literalContext = exports.String_concatContext = exports.String_literalContext = exports.Null_literalContext = exports.Number_literalContext = exports.ElementContext = exports.ElementsContext = exports.List_in_bracketsContext = exports.ListContext = exports.ObjectMemberContext = exports.ObjectMemberListContext = exports.Object_literalContext = exports.ValueContext = exports.Member_colon_listContext = exports.MemberContext = exports.Section_membersContext = exports.Terminal_lineContext = exports.SectionContext = exports.YiniContext = void 0;
+const antlr4_1 = require("antlr4");
+class YiniParser extends antlr4_1.Parser {
+    get grammarFileName() { return "YiniParser.g4"; }
+    get literalNames() { return YiniParser.literalNames; }
+    get symbolicNames() { return YiniParser.symbolicNames; }
+    get ruleNames() { return YiniParser.ruleNames; }
+    get serializedATN() { return YiniParser._serializedATN; }
+    createFailedPredicateException(predicate, message) {
+        return new antlr4_1.FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this._interp = new antlr4_1.ParserATNSimulator(this, YiniParser._ATN, YiniParser.DecisionsToDFA, new antlr4_1.PredictionContextCache());
+    }
+    // @RuleVersion(0)
+    yini() {
+        let localctx = new YiniContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 0, YiniParser.RULE_yini);
+        let _la;
+        try {
+            let _alt;
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 39;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === 28) {
+                    {
+                        this.state = 38;
+                        this.match(YiniParser.SHEBANG);
+                    }
+                }
+                this.state = 44;
+                this._errHandler.sync(this);
+                _alt = this._interp.adaptivePredict(this._input, 1, this._ctx);
+                while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        {
+                            {
+                                this.state = 41;
+                                this.match(YiniParser.INLINE_COMMENT);
+                            }
+                        }
+                    }
+                    this.state = 46;
+                    this._errHandler.sync(this);
+                    _alt = this._interp.adaptivePredict(this._input, 1, this._ctx);
+                }
+                this.state = 50;
+                this._errHandler.sync(this);
+                _alt = this._interp.adaptivePredict(this._input, 2, this._ctx);
+                while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        {
+                            {
+                                this.state = 47;
+                                this.match(YiniParser.NL);
+                            }
+                        }
+                    }
+                    this.state = 52;
+                    this._errHandler.sync(this);
+                    _alt = this._interp.adaptivePredict(this._input, 2, this._ctx);
+                }
+                this.state = 54;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === 1) {
+                    {
+                        this.state = 53;
+                        this.match(YiniParser.YINI_MARKER);
+                    }
+                }
+                this.state = 59;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 46) {
+                    {
+                        {
+                            this.state = 56;
+                            this.match(YiniParser.INLINE_COMMENT);
+                        }
+                    }
+                    this.state = 61;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 65;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 40) {
+                    {
+                        {
+                            this.state = 62;
+                            this.match(YiniParser.NL);
+                        }
+                    }
+                    this.state = 67;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 69;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                do {
+                    {
+                        {
+                            this.state = 68;
+                            this.section();
+                        }
+                    }
+                    this.state = 71;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                } while (_la === 2 || _la === 30);
+                this.state = 76;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 40) {
+                    {
+                        {
+                            this.state = 73;
+                            this.match(YiniParser.NL);
+                        }
+                    }
+                    this.state = 78;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 80;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === 3) {
+                    {
+                        this.state = 79;
+                        this.terminal_line();
+                    }
+                }
+                this.state = 83;
+                this._errHandler.sync(this);
+                switch (this._interp.adaptivePredict(this._input, 9, this._ctx)) {
+                    case 1:
+                        {
+                            this.state = 82;
+                            this.match(YiniParser.EOF);
+                        }
+                        break;
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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, this._ctx, this.state);
+        this.enterRule(localctx, 2, YiniParser.RULE_section);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 86;
+                this._errHandler.sync(this);
+                switch (this._interp.adaptivePredict(this._input, 10, this._ctx)) {
+                    case 1:
+                        {
+                            this.state = 85;
+                            this.match(YiniParser.SECTION_HEAD);
+                        }
+                        break;
+                }
+                this.state = 88;
+                this.section_members();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    terminal_line() {
+        let localctx = new Terminal_lineContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 4, YiniParser.RULE_terminal_line);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 90;
+                this.match(YiniParser.TERMINAL_TOKEN);
+                this.state = 105;
+                this._errHandler.sync(this);
+                switch (this._interp.adaptivePredict(this._input, 14, this._ctx)) {
+                    case 1:
+                        {
+                            this.state = 92;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                            do {
+                                {
+                                    {
+                                        this.state = 91;
+                                        this.match(YiniParser.NL);
+                                    }
+                                }
+                                this.state = 94;
+                                this._errHandler.sync(this);
+                                _la = this._input.LA(1);
+                            } while (_la === 40);
+                        }
+                        break;
+                    case 2:
+                        {
+                            this.state = 97;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                            if (_la === 46) {
+                                {
+                                    this.state = 96;
+                                    this.match(YiniParser.INLINE_COMMENT);
+                                }
+                            }
+                            this.state = 102;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                            while (_la === 40) {
+                                {
+                                    {
+                                        this.state = 99;
+                                        this.match(YiniParser.NL);
+                                    }
+                                }
+                                this.state = 104;
+                                this._errHandler.sync(this);
+                                _la = this._input.LA(1);
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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_members() {
+        let localctx = new Section_membersContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 6, YiniParser.RULE_section_members);
+        try {
+            let _alt;
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 108;
+                this._errHandler.sync(this);
+                _alt = 1;
+                do {
+                    switch (_alt) {
+                        case 1:
+                            {
+                                {
+                                    this.state = 107;
+                                    this.member();
+                                }
+                            }
+                            break;
+                        default:
+                            throw new antlr4_1.NoViableAltException(this);
+                    }
+                    this.state = 110;
+                    this._errHandler.sync(this);
+                    _alt = this._interp.adaptivePredict(this._input, 15, this._ctx);
+                } while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    member() {
+        let localctx = new MemberContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 8, YiniParser.RULE_member);
+        let _la;
+        try {
+            let _alt;
+            this.state = 133;
+            this._errHandler.sync(this);
+            switch (this._interp.adaptivePredict(this._input, 21, this._ctx)) {
+                case 1:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 112;
+                        this.match(YiniParser.KEY);
+                        this.state = 114;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if (_la === 42) {
+                            {
+                                this.state = 113;
+                                this.match(YiniParser.WS);
+                            }
+                        }
+                        this.state = 116;
+                        this.match(YiniParser.EQ);
+                        this.state = 118;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if (_la === 42) {
+                            {
+                                this.state = 117;
+                                this.match(YiniParser.WS);
+                            }
+                        }
+                        this.state = 121;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if (((((_la - 14)) & ~0x1F) === 0 && ((1 << (_la - 14)) & 572933) !== 0)) {
+                            {
+                                this.state = 120;
+                                this.value();
+                            }
+                        }
+                        this.state = 124;
+                        this._errHandler.sync(this);
+                        _alt = 1;
+                        do {
+                            switch (_alt) {
+                                case 1:
+                                    {
+                                        {
+                                            this.state = 123;
+                                            this.match(YiniParser.NL);
+                                        }
+                                    }
+                                    break;
+                                default:
+                                    throw new antlr4_1.NoViableAltException(this);
+                            }
+                            this.state = 126;
+                            this._errHandler.sync(this);
+                            _alt = this._interp.adaptivePredict(this._input, 19, this._ctx);
+                        } while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER);
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 128;
+                        this.member_colon_list();
+                    }
+                    break;
+                case 3:
+                    this.enterOuterAlt(localctx, 3);
+                    {
+                        this.state = 129;
+                        this.match(YiniParser.SECTION_HEAD);
+                        this.state = 131;
+                        this._errHandler.sync(this);
+                        switch (this._interp.adaptivePredict(this._input, 20, this._ctx)) {
+                            case 1:
+                                {
+                                    this.state = 130;
+                                    this.section_members();
+                                }
+                                break;
+                        }
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    member_colon_list() {
+        let localctx = new Member_colon_listContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 10, YiniParser.RULE_member_colon_list);
+        let _la;
+        try {
+            let _alt;
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 135;
+                this.match(YiniParser.KEY);
+                this.state = 136;
+                this.match(YiniParser.COLON);
+                this.state = 138;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === 42) {
+                    {
+                        this.state = 137;
+                        this.match(YiniParser.WS);
+                    }
+                }
+                this.state = 141;
+                this._errHandler.sync(this);
+                switch (this._interp.adaptivePredict(this._input, 23, this._ctx)) {
+                    case 1:
+                        {
+                            this.state = 140;
+                            this.elements();
+                        }
+                        break;
+                }
+                this.state = 144;
+                this._errHandler.sync(this);
+                _alt = 1;
+                do {
+                    switch (_alt) {
+                        case 1:
+                            {
+                                {
+                                    this.state = 143;
+                                    this.match(YiniParser.NL);
+                                }
+                            }
+                            break;
+                        default:
+                            throw new antlr4_1.NoViableAltException(this);
+                    }
+                    this.state = 146;
+                    this._errHandler.sync(this);
+                    _alt = this._interp.adaptivePredict(this._input, 24, this._ctx);
+                } while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    value() {
+        let localctx = new ValueContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 12, YiniParser.RULE_value);
+        try {
+            this.state = 154;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case 25:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 148;
+                        this.null_literal();
+                    }
+                    break;
+                case 33:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 149;
+                        this.string_literal();
+                    }
+                    break;
+                case 29:
+                    this.enterOuterAlt(localctx, 3);
+                    {
+                        this.state = 150;
+                        this.number_literal();
+                    }
+                    break;
+                case 23:
+                case 24:
+                    this.enterOuterAlt(localctx, 4);
+                    {
+                        this.state = 151;
+                        this.boolean_literal();
+                    }
+                    break;
+                case 14:
+                case 27:
+                    this.enterOuterAlt(localctx, 5);
+                    {
+                        this.state = 152;
+                        this.list_in_brackets();
+                    }
+                    break;
+                case 16:
+                case 26:
+                    this.enterOuterAlt(localctx, 6);
+                    {
+                        this.state = 153;
+                        this.object_literal();
+                    }
+                    break;
+                default:
+                    throw new antlr4_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    object_literal() {
+        let localctx = new Object_literalContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 14, YiniParser.RULE_object_literal);
+        let _la;
+        try {
+            let _alt;
+            this.state = 178;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case 16:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 156;
+                        this.match(YiniParser.OC);
+                        this.state = 160;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        while (_la === 40) {
+                            {
+                                {
+                                    this.state = 157;
+                                    this.match(YiniParser.NL);
+                                }
+                            }
+                            this.state = 162;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                        }
+                        this.state = 163;
+                        this.objectMemberList();
+                        this.state = 167;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        while (_la === 40) {
+                            {
+                                {
+                                    this.state = 164;
+                                    this.match(YiniParser.NL);
+                                }
+                            }
+                            this.state = 169;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                        }
+                        this.state = 170;
+                        this.match(YiniParser.CC);
+                        this.state = 174;
+                        this._errHandler.sync(this);
+                        _alt = this._interp.adaptivePredict(this._input, 28, this._ctx);
+                        while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER) {
+                            if (_alt === 1) {
+                                {
+                                    {
+                                        this.state = 171;
+                                        this.match(YiniParser.NL);
+                                    }
+                                }
+                            }
+                            this.state = 176;
+                            this._errHandler.sync(this);
+                            _alt = this._interp.adaptivePredict(this._input, 28, this._ctx);
+                        }
+                    }
+                    break;
+                case 26:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 177;
+                        this.match(YiniParser.EMPTY_OBJECT);
+                    }
+                    break;
+                default:
+                    throw new antlr4_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    objectMemberList() {
+        let localctx = new ObjectMemberListContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 16, YiniParser.RULE_objectMemberList);
+        let _la;
+        try {
+            let _alt;
+            this.state = 198;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case 30:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 180;
+                        this.objectMember();
+                        this.state = 191;
+                        this._errHandler.sync(this);
+                        _alt = this._interp.adaptivePredict(this._input, 31, this._ctx);
+                        while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER) {
+                            if (_alt === 1) {
+                                {
+                                    {
+                                        this.state = 181;
+                                        this.match(YiniParser.COMMA);
+                                        this.state = 185;
+                                        this._errHandler.sync(this);
+                                        _la = this._input.LA(1);
+                                        while (_la === 40) {
+                                            {
+                                                {
+                                                    this.state = 182;
+                                                    this.match(YiniParser.NL);
+                                                }
+                                            }
+                                            this.state = 187;
+                                            this._errHandler.sync(this);
+                                            _la = this._input.LA(1);
+                                        }
+                                        this.state = 188;
+                                        this.objectMember();
+                                    }
+                                }
+                            }
+                            this.state = 193;
+                            this._errHandler.sync(this);
+                            _alt = this._interp.adaptivePredict(this._input, 31, this._ctx);
+                        }
+                        this.state = 195;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if (_la === 12) {
+                            {
+                                this.state = 194;
+                                this.match(YiniParser.COMMA);
+                            }
+                        }
+                    }
+                    break;
+                case 26:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 197;
+                        this.match(YiniParser.EMPTY_OBJECT);
+                    }
+                    break;
+                default:
+                    throw new antlr4_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    objectMember() {
+        let localctx = new ObjectMemberContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 18, YiniParser.RULE_objectMember);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 200;
+                this.match(YiniParser.KEY);
+                this.state = 202;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === 42) {
+                    {
+                        this.state = 201;
+                        this.match(YiniParser.WS);
+                    }
+                }
+                this.state = 204;
+                this.match(YiniParser.EQ);
+                this.state = 208;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 40) {
+                    {
+                        {
+                            this.state = 205;
+                            this.match(YiniParser.NL);
+                        }
+                    }
+                    this.state = 210;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 211;
+                this.value();
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    list() {
+        let localctx = new ListContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 20, YiniParser.RULE_list);
+        try {
+            this.state = 215;
+            this._errHandler.sync(this);
+            switch (this._interp.adaptivePredict(this._input, 36, this._ctx)) {
+                case 1:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 213;
+                        this.elements();
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 214;
+                        this.list_in_brackets();
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    list_in_brackets() {
+        let localctx = new List_in_bracketsContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 22, YiniParser.RULE_list_in_brackets);
+        let _la;
+        try {
+            let _alt;
+            this.state = 234;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case 14:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 217;
+                        this.match(YiniParser.OB);
+                        this.state = 221;
+                        this._errHandler.sync(this);
+                        _alt = this._interp.adaptivePredict(this._input, 37, this._ctx);
+                        while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER) {
+                            if (_alt === 1) {
+                                {
+                                    {
+                                        this.state = 218;
+                                        this.match(YiniParser.NL);
+                                    }
+                                }
+                            }
+                            this.state = 223;
+                            this._errHandler.sync(this);
+                            _alt = this._interp.adaptivePredict(this._input, 37, this._ctx);
+                        }
+                        this.state = 224;
+                        this.elements();
+                        this.state = 228;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        while (_la === 40) {
+                            {
+                                {
+                                    this.state = 225;
+                                    this.match(YiniParser.NL);
+                                }
+                            }
+                            this.state = 230;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                        }
+                        this.state = 231;
+                        this.match(YiniParser.CB);
+                    }
+                    break;
+                case 27:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 233;
+                        this.match(YiniParser.EMPTY_LIST);
+                    }
+                    break;
+                default:
+                    throw new antlr4_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    elements() {
+        let localctx = new ElementsContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 24, YiniParser.RULE_elements);
+        let _la;
+        try {
+            this.state = 244;
+            this._errHandler.sync(this);
+            switch (this._interp.adaptivePredict(this._input, 41, this._ctx)) {
+                case 1:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 236;
+                        this.element();
+                        this.state = 238;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if (_la === 12) {
+                            {
+                                this.state = 237;
+                                this.match(YiniParser.COMMA);
+                            }
+                        }
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 240;
+                        this.element();
+                        this.state = 241;
+                        this.match(YiniParser.COMMA);
+                        this.state = 242;
+                        this.elements();
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    element() {
+        let localctx = new ElementContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 26, YiniParser.RULE_element);
+        let _la;
+        try {
+            let _alt;
+            this.state = 272;
+            this._errHandler.sync(this);
+            switch (this._interp.adaptivePredict(this._input, 46, this._ctx)) {
+                case 1:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 249;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        while (_la === 40) {
+                            {
+                                {
+                                    this.state = 246;
+                                    this.match(YiniParser.NL);
+                                }
+                            }
+                            this.state = 251;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                        }
+                        this.state = 252;
+                        this.value();
+                        this.state = 256;
+                        this._errHandler.sync(this);
+                        _alt = this._interp.adaptivePredict(this._input, 43, this._ctx);
+                        while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER) {
+                            if (_alt === 1) {
+                                {
+                                    {
+                                        this.state = 253;
+                                        this.match(YiniParser.NL);
+                                    }
+                                }
+                            }
+                            this.state = 258;
+                            this._errHandler.sync(this);
+                            _alt = this._interp.adaptivePredict(this._input, 43, this._ctx);
+                        }
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 262;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        while (_la === 40) {
+                            {
+                                {
+                                    this.state = 259;
+                                    this.match(YiniParser.NL);
+                                }
+                            }
+                            this.state = 264;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                        }
+                        this.state = 265;
+                        this.list_in_brackets();
+                        this.state = 269;
+                        this._errHandler.sync(this);
+                        _alt = this._interp.adaptivePredict(this._input, 45, this._ctx);
+                        while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER) {
+                            if (_alt === 1) {
+                                {
+                                    {
+                                        this.state = 266;
+                                        this.match(YiniParser.NL);
+                                    }
+                                }
+                            }
+                            this.state = 271;
+                            this._errHandler.sync(this);
+                            _alt = this._interp.adaptivePredict(this._input, 45, this._ctx);
+                        }
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    number_literal() {
+        let localctx = new Number_literalContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 28, YiniParser.RULE_number_literal);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 274;
+                this.match(YiniParser.NUMBER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    null_literal() {
+        let localctx = new Null_literalContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 30, YiniParser.RULE_null_literal);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 276;
+                this.match(YiniParser.NULL);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    string_literal() {
+        let localctx = new String_literalContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 32, YiniParser.RULE_string_literal);
+        try {
+            let _alt;
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 278;
+                this.match(YiniParser.STRING);
+                this.state = 282;
+                this._errHandler.sync(this);
+                _alt = this._interp.adaptivePredict(this._input, 47, this._ctx);
+                while (_alt !== 2 && _alt !== antlr4_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        {
+                            {
+                                this.state = 279;
+                                this.string_concat();
+                            }
+                        }
+                    }
+                    this.state = 284;
+                    this._errHandler.sync(this);
+                    _alt = this._interp.adaptivePredict(this._input, 47, this._ctx);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    string_concat() {
+        let localctx = new String_concatContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 34, YiniParser.RULE_string_concat);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 288;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 40) {
+                    {
+                        {
+                            this.state = 285;
+                            this.match(YiniParser.NL);
+                        }
+                    }
+                    this.state = 290;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 291;
+                this.match(YiniParser.PLUS);
+                this.state = 295;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 40) {
+                    {
+                        {
+                            this.state = 292;
+                            this.match(YiniParser.NL);
+                        }
+                    }
+                    this.state = 297;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 298;
+                this.match(YiniParser.STRING);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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)
+    boolean_literal() {
+        let localctx = new Boolean_literalContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 36, YiniParser.RULE_boolean_literal);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 300;
+                _la = this._input.LA(1);
+                if (!(_la === 23 || _la === 24)) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr4_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 (!YiniParser.__ATN) {
+            YiniParser.__ATN = new antlr4_1.ATNDeserializer().deserialize(YiniParser._serializedATN);
+        }
+        return YiniParser.__ATN;
+    }
+}
+YiniParser.YINI_MARKER = 1;
+YiniParser.SECTION_HEAD = 2;
+YiniParser.TERMINAL_TOKEN = 3;
+YiniParser.SS = 4;
+YiniParser.EUR = 5;
+YiniParser.CARET = 6;
+YiniParser.TILDE = 7;
+YiniParser.GT = 8;
+YiniParser.LT = 9;
+YiniParser.EQ = 10;
+YiniParser.HASH = 11;
+YiniParser.COMMA = 12;
+YiniParser.COLON = 13;
+YiniParser.OB = 14;
+YiniParser.CB = 15;
+YiniParser.OC = 16;
+YiniParser.CC = 17;
+YiniParser.PLUS = 18;
+YiniParser.DOLLAR = 19;
+YiniParser.PC = 20;
+YiniParser.AT = 21;
+YiniParser.SEMICOLON = 22;
+YiniParser.BOOLEAN_FALSE = 23;
+YiniParser.BOOLEAN_TRUE = 24;
+YiniParser.NULL = 25;
+YiniParser.EMPTY_OBJECT = 26;
+YiniParser.EMPTY_LIST = 27;
+YiniParser.SHEBANG = 28;
+YiniParser.NUMBER = 29;
+YiniParser.KEY = 30;
+YiniParser.IDENT = 31;
+YiniParser.IDENT_BACKTICKED = 32;
+YiniParser.STRING = 33;
+YiniParser.TRIPLE_QUOTED_STRING = 34;
+YiniParser.SINGLE_OR_DOUBLE = 35;
+YiniParser.R_AND_C_STRING = 36;
+YiniParser.HYPER_STRING = 37;
+YiniParser.ESC_SEQ = 38;
+YiniParser.ESC_SEQ_BASE = 39;
+YiniParser.NL = 40;
+YiniParser.SINGLE_NL = 41;
+YiniParser.WS = 42;
+YiniParser.BLOCK_COMMENT = 43;
+YiniParser.COMMENT = 44;
+YiniParser.LINE_COMMENT = 45;
+YiniParser.INLINE_COMMENT = 46;
+YiniParser.IDENT_INVALID = 47;
+YiniParser.EOF = antlr4_1.Token.EOF;
+YiniParser.RULE_yini = 0;
+YiniParser.RULE_section = 1;
+YiniParser.RULE_terminal_line = 2;
+YiniParser.RULE_section_members = 3;
+YiniParser.RULE_member = 4;
+YiniParser.RULE_member_colon_list = 5;
+YiniParser.RULE_value = 6;
+YiniParser.RULE_object_literal = 7;
+YiniParser.RULE_objectMemberList = 8;
+YiniParser.RULE_objectMember = 9;
+YiniParser.RULE_list = 10;
+YiniParser.RULE_list_in_brackets = 11;
+YiniParser.RULE_elements = 12;
+YiniParser.RULE_element = 13;
+YiniParser.RULE_number_literal = 14;
+YiniParser.RULE_null_literal = 15;
+YiniParser.RULE_string_literal = 16;
+YiniParser.RULE_string_concat = 17;
+YiniParser.RULE_boolean_literal = 18;
+YiniParser.literalNames = [null, null,
+    null, null,
+    "'\\u00A7'",
+    "'\\u20AC'",
+    "'^'", "'~'",
+    "'>'", "'<'",
+    "'='", "'#'",
+    "','", "':'",
+    "'['", "']'",
+    "'{'", "'}'",
+    "'+'", "'$'",
+    "'%'", "'@'",
+    "';'"];
+YiniParser.symbolicNames = [null, "YINI_MARKER",
+    "SECTION_HEAD",
+    "TERMINAL_TOKEN",
+    "SS", "EUR",
+    "CARET", "TILDE",
+    "GT", "LT",
+    "EQ", "HASH",
+    "COMMA", "COLON",
+    "OB", "CB",
+    "OC", "CC",
+    "PLUS", "DOLLAR",
+    "PC", "AT",
+    "SEMICOLON",
+    "BOOLEAN_FALSE",
+    "BOOLEAN_TRUE",
+    "NULL", "EMPTY_OBJECT",
+    "EMPTY_LIST",
+    "SHEBANG",
+    "NUMBER", "KEY",
+    "IDENT", "IDENT_BACKTICKED",
+    "STRING", "TRIPLE_QUOTED_STRING",
+    "SINGLE_OR_DOUBLE",
+    "R_AND_C_STRING",
+    "HYPER_STRING",
+    "ESC_SEQ",
+    "ESC_SEQ_BASE",
+    "NL", "SINGLE_NL",
+    "WS", "BLOCK_COMMENT",
+    "COMMENT",
+    "LINE_COMMENT",
+    "INLINE_COMMENT",
+    "IDENT_INVALID"];
+// tslint:disable:no-trailing-whitespace
+YiniParser.ruleNames = [
+    "yini", "section", "terminal_line", "section_members", "member", "member_colon_list",
+    "value", "object_literal", "objectMemberList", "objectMember", "list",
+    "list_in_brackets", "elements", "element", "number_literal", "null_literal",
+    "string_literal", "string_concat", "boolean_literal",
+];
+YiniParser._serializedATN = [4, 1, 47, 303, 2, 0, 7, 0, 2,
+    1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2,
+    10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17,
+    7, 17, 2, 18, 7, 18, 1, 0, 3, 0, 40, 8, 0, 1, 0, 5, 0, 43, 8, 0, 10, 0, 12, 0, 46, 9, 0, 1, 0, 5, 0, 49,
+    8, 0, 10, 0, 12, 0, 52, 9, 0, 1, 0, 3, 0, 55, 8, 0, 1, 0, 5, 0, 58, 8, 0, 10, 0, 12, 0, 61, 9, 0, 1, 0,
+    5, 0, 64, 8, 0, 10, 0, 12, 0, 67, 9, 0, 1, 0, 4, 0, 70, 8, 0, 11, 0, 12, 0, 71, 1, 0, 5, 0, 75, 8, 0,
+    10, 0, 12, 0, 78, 9, 0, 1, 0, 3, 0, 81, 8, 0, 1, 0, 3, 0, 84, 8, 0, 1, 1, 3, 1, 87, 8, 1, 1, 1, 1, 1, 1,
+    2, 1, 2, 4, 2, 93, 8, 2, 11, 2, 12, 2, 94, 1, 2, 3, 2, 98, 8, 2, 1, 2, 5, 2, 101, 8, 2, 10, 2, 12, 2,
+    104, 9, 2, 3, 2, 106, 8, 2, 1, 3, 4, 3, 109, 8, 3, 11, 3, 12, 3, 110, 1, 4, 1, 4, 3, 4, 115, 8, 4, 1,
+    4, 1, 4, 3, 4, 119, 8, 4, 1, 4, 3, 4, 122, 8, 4, 1, 4, 4, 4, 125, 8, 4, 11, 4, 12, 4, 126, 1, 4, 1, 4,
+    1, 4, 3, 4, 132, 8, 4, 3, 4, 134, 8, 4, 1, 5, 1, 5, 1, 5, 3, 5, 139, 8, 5, 1, 5, 3, 5, 142, 8, 5, 1, 5,
+    4, 5, 145, 8, 5, 11, 5, 12, 5, 146, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 155, 8, 6, 1, 7, 1, 7, 5,
+    7, 159, 8, 7, 10, 7, 12, 7, 162, 9, 7, 1, 7, 1, 7, 5, 7, 166, 8, 7, 10, 7, 12, 7, 169, 9, 7, 1, 7, 1,
+    7, 5, 7, 173, 8, 7, 10, 7, 12, 7, 176, 9, 7, 1, 7, 3, 7, 179, 8, 7, 1, 8, 1, 8, 1, 8, 5, 8, 184, 8, 8,
+    10, 8, 12, 8, 187, 9, 8, 1, 8, 5, 8, 190, 8, 8, 10, 8, 12, 8, 193, 9, 8, 1, 8, 3, 8, 196, 8, 8, 1, 8,
+    3, 8, 199, 8, 8, 1, 9, 1, 9, 3, 9, 203, 8, 9, 1, 9, 1, 9, 5, 9, 207, 8, 9, 10, 9, 12, 9, 210, 9, 9, 1,
+    9, 1, 9, 1, 10, 1, 10, 3, 10, 216, 8, 10, 1, 11, 1, 11, 5, 11, 220, 8, 11, 10, 11, 12, 11, 223, 9,
+    11, 1, 11, 1, 11, 5, 11, 227, 8, 11, 10, 11, 12, 11, 230, 9, 11, 1, 11, 1, 11, 1, 11, 3, 11, 235,
+    8, 11, 1, 12, 1, 12, 3, 12, 239, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 245, 8, 12, 1, 13, 5, 13,
+    248, 8, 13, 10, 13, 12, 13, 251, 9, 13, 1, 13, 1, 13, 5, 13, 255, 8, 13, 10, 13, 12, 13, 258, 9,
+    13, 1, 13, 5, 13, 261, 8, 13, 10, 13, 12, 13, 264, 9, 13, 1, 13, 1, 13, 5, 13, 268, 8, 13, 10, 13,
+    12, 13, 271, 9, 13, 3, 13, 273, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 5, 16, 281, 8, 16,
+    10, 16, 12, 16, 284, 9, 16, 1, 17, 5, 17, 287, 8, 17, 10, 17, 12, 17, 290, 9, 17, 1, 17, 1, 17,
+    5, 17, 294, 8, 17, 10, 17, 12, 17, 297, 9, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 0, 0, 19, 0, 2,
+    4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 0, 1, 1, 0, 23, 24, 338, 0, 39,
+    1, 0, 0, 0, 2, 86, 1, 0, 0, 0, 4, 90, 1, 0, 0, 0, 6, 108, 1, 0, 0, 0, 8, 133, 1, 0, 0, 0, 10, 135, 1,
+    0, 0, 0, 12, 154, 1, 0, 0, 0, 14, 178, 1, 0, 0, 0, 16, 198, 1, 0, 0, 0, 18, 200, 1, 0, 0, 0, 20, 215,
+    1, 0, 0, 0, 22, 234, 1, 0, 0, 0, 24, 244, 1, 0, 0, 0, 26, 272, 1, 0, 0, 0, 28, 274, 1, 0, 0, 0, 30,
+    276, 1, 0, 0, 0, 32, 278, 1, 0, 0, 0, 34, 288, 1, 0, 0, 0, 36, 300, 1, 0, 0, 0, 38, 40, 5, 28, 0, 0,
+    39, 38, 1, 0, 0, 0, 39, 40, 1, 0, 0, 0, 40, 44, 1, 0, 0, 0, 41, 43, 5, 46, 0, 0, 42, 41, 1, 0, 0, 0,
+    43, 46, 1, 0, 0, 0, 44, 42, 1, 0, 0, 0, 44, 45, 1, 0, 0, 0, 45, 50, 1, 0, 0, 0, 46, 44, 1, 0, 0, 0, 47,
+    49, 5, 40, 0, 0, 48, 47, 1, 0, 0, 0, 49, 52, 1, 0, 0, 0, 50, 48, 1, 0, 0, 0, 50, 51, 1, 0, 0, 0, 51,
+    54, 1, 0, 0, 0, 52, 50, 1, 0, 0, 0, 53, 55, 5, 1, 0, 0, 54, 53, 1, 0, 0, 0, 54, 55, 1, 0, 0, 0, 55, 59,
+    1, 0, 0, 0, 56, 58, 5, 46, 0, 0, 57, 56, 1, 0, 0, 0, 58, 61, 1, 0, 0, 0, 59, 57, 1, 0, 0, 0, 59, 60,
+    1, 0, 0, 0, 60, 65, 1, 0, 0, 0, 61, 59, 1, 0, 0, 0, 62, 64, 5, 40, 0, 0, 63, 62, 1, 0, 0, 0, 64, 67,
+    1, 0, 0, 0, 65, 63, 1, 0, 0, 0, 65, 66, 1, 0, 0, 0, 66, 69, 1, 0, 0, 0, 67, 65, 1, 0, 0, 0, 68, 70, 3,
+    2, 1, 0, 69, 68, 1, 0, 0, 0, 70, 71, 1, 0, 0, 0, 71, 69, 1, 0, 0, 0, 71, 72, 1, 0, 0, 0, 72, 76, 1, 0,
+    0, 0, 73, 75, 5, 40, 0, 0, 74, 73, 1, 0, 0, 0, 75, 78, 1, 0, 0, 0, 76, 74, 1, 0, 0, 0, 76, 77, 1, 0,
+    0, 0, 77, 80, 1, 0, 0, 0, 78, 76, 1, 0, 0, 0, 79, 81, 3, 4, 2, 0, 80, 79, 1, 0, 0, 0, 80, 81, 1, 0, 0,
+    0, 81, 83, 1, 0, 0, 0, 82, 84, 5, 0, 0, 1, 83, 82, 1, 0, 0, 0, 83, 84, 1, 0, 0, 0, 84, 1, 1, 0, 0, 0,
+    85, 87, 5, 2, 0, 0, 86, 85, 1, 0, 0, 0, 86, 87, 1, 0, 0, 0, 87, 88, 1, 0, 0, 0, 88, 89, 3, 6, 3, 0, 89,
+    3, 1, 0, 0, 0, 90, 105, 5, 3, 0, 0, 91, 93, 5, 40, 0, 0, 92, 91, 1, 0, 0, 0, 93, 94, 1, 0, 0, 0, 94,
+    92, 1, 0, 0, 0, 94, 95, 1, 0, 0, 0, 95, 106, 1, 0, 0, 0, 96, 98, 5, 46, 0, 0, 97, 96, 1, 0, 0, 0, 97,
+    98, 1, 0, 0, 0, 98, 102, 1, 0, 0, 0, 99, 101, 5, 40, 0, 0, 100, 99, 1, 0, 0, 0, 101, 104, 1, 0, 0,
+    0, 102, 100, 1, 0, 0, 0, 102, 103, 1, 0, 0, 0, 103, 106, 1, 0, 0, 0, 104, 102, 1, 0, 0, 0, 105, 92,
+    1, 0, 0, 0, 105, 97, 1, 0, 0, 0, 106, 5, 1, 0, 0, 0, 107, 109, 3, 8, 4, 0, 108, 107, 1, 0, 0, 0, 109,
+    110, 1, 0, 0, 0, 110, 108, 1, 0, 0, 0, 110, 111, 1, 0, 0, 0, 111, 7, 1, 0, 0, 0, 112, 114, 5, 30,
+    0, 0, 113, 115, 5, 42, 0, 0, 114, 113, 1, 0, 0, 0, 114, 115, 1, 0, 0, 0, 115, 116, 1, 0, 0, 0, 116,
+    118, 5, 10, 0, 0, 117, 119, 5, 42, 0, 0, 118, 117, 1, 0, 0, 0, 118, 119, 1, 0, 0, 0, 119, 121, 1,
+    0, 0, 0, 120, 122, 3, 12, 6, 0, 121, 120, 1, 0, 0, 0, 121, 122, 1, 0, 0, 0, 122, 124, 1, 0, 0, 0,
+    123, 125, 5, 40, 0, 0, 124, 123, 1, 0, 0, 0, 125, 126, 1, 0, 0, 0, 126, 124, 1, 0, 0, 0, 126, 127,
+    1, 0, 0, 0, 127, 134, 1, 0, 0, 0, 128, 134, 3, 10, 5, 0, 129, 131, 5, 2, 0, 0, 130, 132, 3, 6, 3,
+    0, 131, 130, 1, 0, 0, 0, 131, 132, 1, 0, 0, 0, 132, 134, 1, 0, 0, 0, 133, 112, 1, 0, 0, 0, 133, 128,
+    1, 0, 0, 0, 133, 129, 1, 0, 0, 0, 134, 9, 1, 0, 0, 0, 135, 136, 5, 30, 0, 0, 136, 138, 5, 13, 0, 0,
+    137, 139, 5, 42, 0, 0, 138, 137, 1, 0, 0, 0, 138, 139, 1, 0, 0, 0, 139, 141, 1, 0, 0, 0, 140, 142,
+    3, 24, 12, 0, 141, 140, 1, 0, 0, 0, 141, 142, 1, 0, 0, 0, 142, 144, 1, 0, 0, 0, 143, 145, 5, 40,
+    0, 0, 144, 143, 1, 0, 0, 0, 145, 146, 1, 0, 0, 0, 146, 144, 1, 0, 0, 0, 146, 147, 1, 0, 0, 0, 147,
+    11, 1, 0, 0, 0, 148, 155, 3, 30, 15, 0, 149, 155, 3, 32, 16, 0, 150, 155, 3, 28, 14, 0, 151, 155,
+    3, 36, 18, 0, 152, 155, 3, 22, 11, 0, 153, 155, 3, 14, 7, 0, 154, 148, 1, 0, 0, 0, 154, 149, 1,
+    0, 0, 0, 154, 150, 1, 0, 0, 0, 154, 151, 1, 0, 0, 0, 154, 152, 1, 0, 0, 0, 154, 153, 1, 0, 0, 0, 155,
+    13, 1, 0, 0, 0, 156, 160, 5, 16, 0, 0, 157, 159, 5, 40, 0, 0, 158, 157, 1, 0, 0, 0, 159, 162, 1,
+    0, 0, 0, 160, 158, 1, 0, 0, 0, 160, 161, 1, 0, 0, 0, 161, 163, 1, 0, 0, 0, 162, 160, 1, 0, 0, 0, 163,
+    167, 3, 16, 8, 0, 164, 166, 5, 40, 0, 0, 165, 164, 1, 0, 0, 0, 166, 169, 1, 0, 0, 0, 167, 165, 1,
+    0, 0, 0, 167, 168, 1, 0, 0, 0, 168, 170, 1, 0, 0, 0, 169, 167, 1, 0, 0, 0, 170, 174, 5, 17, 0, 0,
+    171, 173, 5, 40, 0, 0, 172, 171, 1, 0, 0, 0, 173, 176, 1, 0, 0, 0, 174, 172, 1, 0, 0, 0, 174, 175,
+    1, 0, 0, 0, 175, 179, 1, 0, 0, 0, 176, 174, 1, 0, 0, 0, 177, 179, 5, 26, 0, 0, 178, 156, 1, 0, 0,
+    0, 178, 177, 1, 0, 0, 0, 179, 15, 1, 0, 0, 0, 180, 191, 3, 18, 9, 0, 181, 185, 5, 12, 0, 0, 182,
+    184, 5, 40, 0, 0, 183, 182, 1, 0, 0, 0, 184, 187, 1, 0, 0, 0, 185, 183, 1, 0, 0, 0, 185, 186, 1,
+    0, 0, 0, 186, 188, 1, 0, 0, 0, 187, 185, 1, 0, 0, 0, 188, 190, 3, 18, 9, 0, 189, 181, 1, 0, 0, 0,
+    190, 193, 1, 0, 0, 0, 191, 189, 1, 0, 0, 0, 191, 192, 1, 0, 0, 0, 192, 195, 1, 0, 0, 0, 193, 191,
+    1, 0, 0, 0, 194, 196, 5, 12, 0, 0, 195, 194, 1, 0, 0, 0, 195, 196, 1, 0, 0, 0, 196, 199, 1, 0, 0,
+    0, 197, 199, 5, 26, 0, 0, 198, 180, 1, 0, 0, 0, 198, 197, 1, 0, 0, 0, 199, 17, 1, 0, 0, 0, 200, 202,
+    5, 30, 0, 0, 201, 203, 5, 42, 0, 0, 202, 201, 1, 0, 0, 0, 202, 203, 1, 0, 0, 0, 203, 204, 1, 0, 0,
+    0, 204, 208, 5, 10, 0, 0, 205, 207, 5, 40, 0, 0, 206, 205, 1, 0, 0, 0, 207, 210, 1, 0, 0, 0, 208,
+    206, 1, 0, 0, 0, 208, 209, 1, 0, 0, 0, 209, 211, 1, 0, 0, 0, 210, 208, 1, 0, 0, 0, 211, 212, 3, 12,
+    6, 0, 212, 19, 1, 0, 0, 0, 213, 216, 3, 24, 12, 0, 214, 216, 3, 22, 11, 0, 215, 213, 1, 0, 0, 0,
+    215, 214, 1, 0, 0, 0, 216, 21, 1, 0, 0, 0, 217, 221, 5, 14, 0, 0, 218, 220, 5, 40, 0, 0, 219, 218,
+    1, 0, 0, 0, 220, 223, 1, 0, 0, 0, 221, 219, 1, 0, 0, 0, 221, 222, 1, 0, 0, 0, 222, 224, 1, 0, 0, 0,
+    223, 221, 1, 0, 0, 0, 224, 228, 3, 24, 12, 0, 225, 227, 5, 40, 0, 0, 226, 225, 1, 0, 0, 0, 227,
+    230, 1, 0, 0, 0, 228, 226, 1, 0, 0, 0, 228, 229, 1, 0, 0, 0, 229, 231, 1, 0, 0, 0, 230, 228, 1, 0,
+    0, 0, 231, 232, 5, 15, 0, 0, 232, 235, 1, 0, 0, 0, 233, 235, 5, 27, 0, 0, 234, 217, 1, 0, 0, 0, 234,
+    233, 1, 0, 0, 0, 235, 23, 1, 0, 0, 0, 236, 238, 3, 26, 13, 0, 237, 239, 5, 12, 0, 0, 238, 237, 1,
+    0, 0, 0, 238, 239, 1, 0, 0, 0, 239, 245, 1, 0, 0, 0, 240, 241, 3, 26, 13, 0, 241, 242, 5, 12, 0,
+    0, 242, 243, 3, 24, 12, 0, 243, 245, 1, 0, 0, 0, 244, 236, 1, 0, 0, 0, 244, 240, 1, 0, 0, 0, 245,
+    25, 1, 0, 0, 0, 246, 248, 5, 40, 0, 0, 247, 246, 1, 0, 0, 0, 248, 251, 1, 0, 0, 0, 249, 247, 1, 0,
+    0, 0, 249, 250, 1, 0, 0, 0, 250, 252, 1, 0, 0, 0, 251, 249, 1, 0, 0, 0, 252, 256, 3, 12, 6, 0, 253,
+    255, 5, 40, 0, 0, 254, 253, 1, 0, 0, 0, 255, 258, 1, 0, 0, 0, 256, 254, 1, 0, 0, 0, 256, 257, 1,
+    0, 0, 0, 257, 273, 1, 0, 0, 0, 258, 256, 1, 0, 0, 0, 259, 261, 5, 40, 0, 0, 260, 259, 1, 0, 0, 0,
+    261, 264, 1, 0, 0, 0, 262, 260, 1, 0, 0, 0, 262, 263, 1, 0, 0, 0, 263, 265, 1, 0, 0, 0, 264, 262,
+    1, 0, 0, 0, 265, 269, 3, 22, 11, 0, 266, 268, 5, 40, 0, 0, 267, 266, 1, 0, 0, 0, 268, 271, 1, 0,
+    0, 0, 269, 267, 1, 0, 0, 0, 269, 270, 1, 0, 0, 0, 270, 273, 1, 0, 0, 0, 271, 269, 1, 0, 0, 0, 272,
+    249, 1, 0, 0, 0, 272, 262, 1, 0, 0, 0, 273, 27, 1, 0, 0, 0, 274, 275, 5, 29, 0, 0, 275, 29, 1, 0,
+    0, 0, 276, 277, 5, 25, 0, 0, 277, 31, 1, 0, 0, 0, 278, 282, 5, 33, 0, 0, 279, 281, 3, 34, 17, 0,
+    280, 279, 1, 0, 0, 0, 281, 284, 1, 0, 0, 0, 282, 280, 1, 0, 0, 0, 282, 283, 1, 0, 0, 0, 283, 33,
+    1, 0, 0, 0, 284, 282, 1, 0, 0, 0, 285, 287, 5, 40, 0, 0, 286, 285, 1, 0, 0, 0, 287, 290, 1, 0, 0,
+    0, 288, 286, 1, 0, 0, 0, 288, 289, 1, 0, 0, 0, 289, 291, 1, 0, 0, 0, 290, 288, 1, 0, 0, 0, 291, 295,
+    5, 18, 0, 0, 292, 294, 5, 40, 0, 0, 293, 292, 1, 0, 0, 0, 294, 297, 1, 0, 0, 0, 295, 293, 1, 0, 0,
+    0, 295, 296, 1, 0, 0, 0, 296, 298, 1, 0, 0, 0, 297, 295, 1, 0, 0, 0, 298, 299, 5, 33, 0, 0, 299,
+    35, 1, 0, 0, 0, 300, 301, 7, 0, 0, 0, 301, 37, 1, 0, 0, 0, 50, 39, 44, 50, 54, 59, 65, 71, 76, 80,
+    83, 86, 94, 97, 102, 105, 110, 114, 118, 121, 126, 131, 133, 138, 141, 146, 154, 160, 167,
+    174, 178, 185, 191, 195, 198, 202, 208, 215, 221, 228, 234, 238, 244, 249, 256, 262, 269,
+    272, 282, 288, 295];
+YiniParser.DecisionsToDFA = YiniParser._ATN.decisionToState.map((ds, index) => new antlr4_1.DFA(ds, index));
+exports.default = YiniParser;
+class YiniContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    SHEBANG() {
+        return this.getToken(YiniParser.SHEBANG, 0);
+    }
+    INLINE_COMMENT_list() {
+        return this.getTokens(YiniParser.INLINE_COMMENT);
+    }
+    INLINE_COMMENT(i) {
+        return this.getToken(YiniParser.INLINE_COMMENT, i);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    YINI_MARKER() {
+        return this.getToken(YiniParser.YINI_MARKER, 0);
+    }
+    section_list() {
+        return this.getTypedRuleContexts(SectionContext);
+    }
+    section(i) {
+        return this.getTypedRuleContext(SectionContext, i);
+    }
+    terminal_line() {
+        return this.getTypedRuleContext(Terminal_lineContext, 0);
+    }
+    EOF() {
+        return this.getToken(YiniParser.EOF, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_yini;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitYini) {
+            return visitor.visitYini(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.YiniContext = YiniContext;
+class SectionContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    section_members() {
+        return this.getTypedRuleContext(Section_membersContext, 0);
+    }
+    SECTION_HEAD() {
+        return this.getToken(YiniParser.SECTION_HEAD, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_section;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitSection) {
+            return visitor.visitSection(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.SectionContext = SectionContext;
+class Terminal_lineContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    TERMINAL_TOKEN() {
+        return this.getToken(YiniParser.TERMINAL_TOKEN, 0);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    INLINE_COMMENT() {
+        return this.getToken(YiniParser.INLINE_COMMENT, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_terminal_line;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTerminal_line) {
+            return visitor.visitTerminal_line(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.Terminal_lineContext = Terminal_lineContext;
+class Section_membersContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    member_list() {
+        return this.getTypedRuleContexts(MemberContext);
+    }
+    member(i) {
+        return this.getTypedRuleContext(MemberContext, i);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_section_members;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitSection_members) {
+            return visitor.visitSection_members(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.Section_membersContext = Section_membersContext;
+class MemberContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    KEY() {
+        return this.getToken(YiniParser.KEY, 0);
+    }
+    EQ() {
+        return this.getToken(YiniParser.EQ, 0);
+    }
+    WS_list() {
+        return this.getTokens(YiniParser.WS);
+    }
+    WS(i) {
+        return this.getToken(YiniParser.WS, i);
+    }
+    value() {
+        return this.getTypedRuleContext(ValueContext, 0);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    member_colon_list() {
+        return this.getTypedRuleContext(Member_colon_listContext, 0);
+    }
+    SECTION_HEAD() {
+        return this.getToken(YiniParser.SECTION_HEAD, 0);
+    }
+    section_members() {
+        return this.getTypedRuleContext(Section_membersContext, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_member;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitMember) {
+            return visitor.visitMember(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.MemberContext = MemberContext;
+class Member_colon_listContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    KEY() {
+        return this.getToken(YiniParser.KEY, 0);
+    }
+    COLON() {
+        return this.getToken(YiniParser.COLON, 0);
+    }
+    WS() {
+        return this.getToken(YiniParser.WS, 0);
+    }
+    elements() {
+        return this.getTypedRuleContext(ElementsContext, 0);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_member_colon_list;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitMember_colon_list) {
+            return visitor.visitMember_colon_list(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.Member_colon_listContext = Member_colon_listContext;
+class ValueContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    null_literal() {
+        return this.getTypedRuleContext(Null_literalContext, 0);
+    }
+    string_literal() {
+        return this.getTypedRuleContext(String_literalContext, 0);
+    }
+    number_literal() {
+        return this.getTypedRuleContext(Number_literalContext, 0);
+    }
+    boolean_literal() {
+        return this.getTypedRuleContext(Boolean_literalContext, 0);
+    }
+    list_in_brackets() {
+        return this.getTypedRuleContext(List_in_bracketsContext, 0);
+    }
+    object_literal() {
+        return this.getTypedRuleContext(Object_literalContext, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_value;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitValue) {
+            return visitor.visitValue(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ValueContext = ValueContext;
+class Object_literalContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    OC() {
+        return this.getToken(YiniParser.OC, 0);
+    }
+    objectMemberList() {
+        return this.getTypedRuleContext(ObjectMemberListContext, 0);
+    }
+    CC() {
+        return this.getToken(YiniParser.CC, 0);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    EMPTY_OBJECT() {
+        return this.getToken(YiniParser.EMPTY_OBJECT, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_object_literal;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitObject_literal) {
+            return visitor.visitObject_literal(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.Object_literalContext = Object_literalContext;
+class ObjectMemberListContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    objectMember_list() {
+        return this.getTypedRuleContexts(ObjectMemberContext);
+    }
+    objectMember(i) {
+        return this.getTypedRuleContext(ObjectMemberContext, i);
+    }
+    COMMA_list() {
+        return this.getTokens(YiniParser.COMMA);
+    }
+    COMMA(i) {
+        return this.getToken(YiniParser.COMMA, i);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    EMPTY_OBJECT() {
+        return this.getToken(YiniParser.EMPTY_OBJECT, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_objectMemberList;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitObjectMemberList) {
+            return visitor.visitObjectMemberList(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ObjectMemberListContext = ObjectMemberListContext;
+class ObjectMemberContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    KEY() {
+        return this.getToken(YiniParser.KEY, 0);
+    }
+    EQ() {
+        return this.getToken(YiniParser.EQ, 0);
+    }
+    value() {
+        return this.getTypedRuleContext(ValueContext, 0);
+    }
+    WS() {
+        return this.getToken(YiniParser.WS, 0);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_objectMember;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitObjectMember) {
+            return visitor.visitObjectMember(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ObjectMemberContext = ObjectMemberContext;
+class ListContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    elements() {
+        return this.getTypedRuleContext(ElementsContext, 0);
+    }
+    list_in_brackets() {
+        return this.getTypedRuleContext(List_in_bracketsContext, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_list;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitList) {
+            return visitor.visitList(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ListContext = ListContext;
+class List_in_bracketsContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    OB() {
+        return this.getToken(YiniParser.OB, 0);
+    }
+    elements() {
+        return this.getTypedRuleContext(ElementsContext, 0);
+    }
+    CB() {
+        return this.getToken(YiniParser.CB, 0);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    EMPTY_LIST() {
+        return this.getToken(YiniParser.EMPTY_LIST, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_list_in_brackets;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitList_in_brackets) {
+            return visitor.visitList_in_brackets(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.List_in_bracketsContext = List_in_bracketsContext;
+class ElementsContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    element() {
+        return this.getTypedRuleContext(ElementContext, 0);
+    }
+    COMMA() {
+        return this.getToken(YiniParser.COMMA, 0);
+    }
+    elements() {
+        return this.getTypedRuleContext(ElementsContext, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_elements;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitElements) {
+            return visitor.visitElements(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ElementsContext = ElementsContext;
+class ElementContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    value() {
+        return this.getTypedRuleContext(ValueContext, 0);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    list_in_brackets() {
+        return this.getTypedRuleContext(List_in_bracketsContext, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_element;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitElement) {
+            return visitor.visitElement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ElementContext = ElementContext;
+class Number_literalContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    NUMBER() {
+        return this.getToken(YiniParser.NUMBER, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_number_literal;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitNumber_literal) {
+            return visitor.visitNumber_literal(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.Number_literalContext = Number_literalContext;
+class Null_literalContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    NULL() {
+        return this.getToken(YiniParser.NULL, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_null_literal;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitNull_literal) {
+            return visitor.visitNull_literal(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.Null_literalContext = Null_literalContext;
+class String_literalContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    STRING() {
+        return this.getToken(YiniParser.STRING, 0);
+    }
+    string_concat_list() {
+        return this.getTypedRuleContexts(String_concatContext);
+    }
+    string_concat(i) {
+        return this.getTypedRuleContext(String_concatContext, i);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_string_literal;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitString_literal) {
+            return visitor.visitString_literal(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.String_literalContext = String_literalContext;
+class String_concatContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    PLUS() {
+        return this.getToken(YiniParser.PLUS, 0);
+    }
+    STRING() {
+        return this.getToken(YiniParser.STRING, 0);
+    }
+    NL_list() {
+        return this.getTokens(YiniParser.NL);
+    }
+    NL(i) {
+        return this.getToken(YiniParser.NL, i);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_string_concat;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitString_concat) {
+            return visitor.visitString_concat(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.String_concatContext = String_concatContext;
+class Boolean_literalContext extends antlr4_1.ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    BOOLEAN_FALSE() {
+        return this.getToken(YiniParser.BOOLEAN_FALSE, 0);
+    }
+    BOOLEAN_TRUE() {
+        return this.getToken(YiniParser.BOOLEAN_TRUE, 0);
+    }
+    get ruleIndex() {
+        return YiniParser.RULE_boolean_literal;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitBoolean_literal) {
+            return visitor.visitBoolean_literal(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.Boolean_literalContext = Boolean_literalContext;