@plurnk/plurnk-grammar 0.2.0 → 0.5.0

package/dist/src/generated/plurnkParser.js

@@ -0,0 +1,1833 @@
+import * as antlr from "antlr4ng";
+export class plurnkParser extends antlr.Parser {
+    static LBRACKET = 1;
+    static RBRACKET = 2;
+    static LPAREN = 3;
+    static RPAREN = 4;
+    static L_MARKER = 5;
+    static COLON = 6;
+    static COMMA = 7;
+    static INT = 8;
+    static IDENT = 9;
+    static TAG = 10;
+    static PATH_TEXT = 11;
+    static BODY_TEXT = 12;
+    static CLOSE_TAG = 13;
+    static TEXT = 14;
+    static OPEN_FIND = 15;
+    static OPEN_READ = 16;
+    static OPEN_EDIT = 17;
+    static OPEN_COPY = 18;
+    static OPEN_MOVE = 19;
+    static OPEN_SHOW = 20;
+    static OPEN_HIDE = 21;
+    static OPEN_SEND = 22;
+    static OPEN_EXEC = 23;
+    static SLOTS_WS = 24;
+    static ST_WS = 25;
+    static SI_WS = 26;
+    static SD_WS = 27;
+    static ST_COMMA = 28;
+    static B_COLON = 29;
+    static RULE_document = 0;
+    static RULE_statement = 1;
+    static RULE_findStatement = 2;
+    static RULE_readStatement = 3;
+    static RULE_editStatement = 4;
+    static RULE_copyStatement = 5;
+    static RULE_moveStatement = 6;
+    static RULE_showStatement = 7;
+    static RULE_hideStatement = 8;
+    static RULE_sendStatement = 9;
+    static RULE_execStatement = 10;
+    static RULE_tagOpModifiers = 11;
+    static RULE_sendModifiers = 12;
+    static RULE_execModifiers = 13;
+    static RULE_tagSignal = 14;
+    static RULE_intSignal = 15;
+    static RULE_identSignal = 16;
+    static RULE_path = 17;
+    static RULE_lineMarker = 18;
+    static RULE_body = 19;
+    static literalNames = [
+        null, null, null, null, null, null, null, null, null, null, null,
+        null, null, null, null, null, null, null, null, null, null, null,
+        null, null, null, null, null, null, "','", "':'"
+    ];
+    static symbolicNames = [
+        null, "LBRACKET", "RBRACKET", "LPAREN", "RPAREN", "L_MARKER", "COLON",
+        "COMMA", "INT", "IDENT", "TAG", "PATH_TEXT", "BODY_TEXT", "CLOSE_TAG",
+        "TEXT", "OPEN_FIND", "OPEN_READ", "OPEN_EDIT", "OPEN_COPY", "OPEN_MOVE",
+        "OPEN_SHOW", "OPEN_HIDE", "OPEN_SEND", "OPEN_EXEC", "SLOTS_WS",
+        "ST_WS", "SI_WS", "SD_WS", "ST_COMMA", "B_COLON"
+    ];
+    static ruleNames = [
+        "document", "statement", "findStatement", "readStatement", "editStatement",
+        "copyStatement", "moveStatement", "showStatement", "hideStatement",
+        "sendStatement", "execStatement", "tagOpModifiers", "sendModifiers",
+        "execModifiers", "tagSignal", "intSignal", "identSignal", "path",
+        "lineMarker", "body",
+    ];
+    get grammarFileName() { return "plurnkParser.g4"; }
+    get literalNames() { return plurnkParser.literalNames; }
+    get symbolicNames() { return plurnkParser.symbolicNames; }
+    get ruleNames() { return plurnkParser.ruleNames; }
+    get serializedATN() { return plurnkParser._serializedATN; }
+    createFailedPredicateException(predicate, message) {
+        return new antlr.FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this.interpreter = new antlr.ParserATNSimulator(this, plurnkParser._ATN, plurnkParser.decisionsToDFA, new antlr.PredictionContextCache());
+    }
+    document() {
+        let localContext = new DocumentContext(this.context, this.state);
+        this.enterRule(localContext, 0, plurnkParser.RULE_document);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 44;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 16760832) !== 0)) {
+                    {
+                        this.state = 42;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                            case plurnkParser.OPEN_FIND:
+                            case plurnkParser.OPEN_READ:
+                            case plurnkParser.OPEN_EDIT:
+                            case plurnkParser.OPEN_COPY:
+                            case plurnkParser.OPEN_MOVE:
+                            case plurnkParser.OPEN_SHOW:
+                            case plurnkParser.OPEN_HIDE:
+                            case plurnkParser.OPEN_SEND:
+                            case plurnkParser.OPEN_EXEC:
+                                {
+                                    this.state = 40;
+                                    this.statement();
+                                }
+                                break;
+                            case plurnkParser.TEXT:
+                                {
+                                    this.state = 41;
+                                    this.match(plurnkParser.TEXT);
+                                }
+                                break;
+                            default:
+                                throw new antlr.NoViableAltException(this);
+                        }
+                    }
+                    this.state = 46;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 47;
+                this.match(plurnkParser.EOF);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    statement() {
+        let localContext = new StatementContext(this.context, this.state);
+        this.enterRule(localContext, 2, plurnkParser.RULE_statement);
+        try {
+            this.state = 58;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+                case plurnkParser.OPEN_FIND:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 49;
+                        this.findStatement();
+                    }
+                    break;
+                case plurnkParser.OPEN_READ:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 50;
+                        this.readStatement();
+                    }
+                    break;
+                case plurnkParser.OPEN_EDIT:
+                    this.enterOuterAlt(localContext, 3);
+                    {
+                        this.state = 51;
+                        this.editStatement();
+                    }
+                    break;
+                case plurnkParser.OPEN_COPY:
+                    this.enterOuterAlt(localContext, 4);
+                    {
+                        this.state = 52;
+                        this.copyStatement();
+                    }
+                    break;
+                case plurnkParser.OPEN_MOVE:
+                    this.enterOuterAlt(localContext, 5);
+                    {
+                        this.state = 53;
+                        this.moveStatement();
+                    }
+                    break;
+                case plurnkParser.OPEN_SHOW:
+                    this.enterOuterAlt(localContext, 6);
+                    {
+                        this.state = 54;
+                        this.showStatement();
+                    }
+                    break;
+                case plurnkParser.OPEN_HIDE:
+                    this.enterOuterAlt(localContext, 7);
+                    {
+                        this.state = 55;
+                        this.hideStatement();
+                    }
+                    break;
+                case plurnkParser.OPEN_SEND:
+                    this.enterOuterAlt(localContext, 8);
+                    {
+                        this.state = 56;
+                        this.sendStatement();
+                    }
+                    break;
+                case plurnkParser.OPEN_EXEC:
+                    this.enterOuterAlt(localContext, 9);
+                    {
+                        this.state = 57;
+                        this.execStatement();
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    findStatement() {
+        let localContext = new FindStatementContext(this.context, this.state);
+        this.enterRule(localContext, 4, plurnkParser.RULE_findStatement);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 60;
+                this.match(plurnkParser.OPEN_FIND);
+                this.state = 62;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
+                    {
+                        this.state = 61;
+                        this.tagOpModifiers();
+                    }
+                }
+                this.state = 64;
+                this.match(plurnkParser.COLON);
+                this.state = 66;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 12) {
+                    {
+                        this.state = 65;
+                        this.body();
+                    }
+                }
+                this.state = 68;
+                this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    readStatement() {
+        let localContext = new ReadStatementContext(this.context, this.state);
+        this.enterRule(localContext, 6, plurnkParser.RULE_readStatement);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 70;
+                this.match(plurnkParser.OPEN_READ);
+                this.state = 72;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
+                    {
+                        this.state = 71;
+                        this.tagOpModifiers();
+                    }
+                }
+                this.state = 74;
+                this.match(plurnkParser.COLON);
+                this.state = 76;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 12) {
+                    {
+                        this.state = 75;
+                        this.body();
+                    }
+                }
+                this.state = 78;
+                this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    editStatement() {
+        let localContext = new EditStatementContext(this.context, this.state);
+        this.enterRule(localContext, 8, plurnkParser.RULE_editStatement);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 80;
+                this.match(plurnkParser.OPEN_EDIT);
+                this.state = 82;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
+                    {
+                        this.state = 81;
+                        this.tagOpModifiers();
+                    }
+                }
+                this.state = 84;
+                this.match(plurnkParser.COLON);
+                this.state = 86;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 12) {
+                    {
+                        this.state = 85;
+                        this.body();
+                    }
+                }
+                this.state = 88;
+                this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    copyStatement() {
+        let localContext = new CopyStatementContext(this.context, this.state);
+        this.enterRule(localContext, 10, plurnkParser.RULE_copyStatement);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 90;
+                this.match(plurnkParser.OPEN_COPY);
+                this.state = 92;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
+                    {
+                        this.state = 91;
+                        this.tagOpModifiers();
+                    }
+                }
+                this.state = 94;
+                this.match(plurnkParser.COLON);
+                this.state = 96;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 12) {
+                    {
+                        this.state = 95;
+                        this.body();
+                    }
+                }
+                this.state = 98;
+                this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    moveStatement() {
+        let localContext = new MoveStatementContext(this.context, this.state);
+        this.enterRule(localContext, 12, plurnkParser.RULE_moveStatement);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 100;
+                this.match(plurnkParser.OPEN_MOVE);
+                this.state = 102;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
+                    {
+                        this.state = 101;
+                        this.tagOpModifiers();
+                    }
+                }
+                this.state = 104;
+                this.match(plurnkParser.COLON);
+                this.state = 106;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 12) {
+                    {
+                        this.state = 105;
+                        this.body();
+                    }
+                }
+                this.state = 108;
+                this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    showStatement() {
+        let localContext = new ShowStatementContext(this.context, this.state);
+        this.enterRule(localContext, 14, plurnkParser.RULE_showStatement);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 110;
+                this.match(plurnkParser.OPEN_SHOW);
+                this.state = 112;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
+                    {
+                        this.state = 111;
+                        this.tagOpModifiers();
+                    }
+                }
+                this.state = 114;
+                this.match(plurnkParser.COLON);
+                this.state = 116;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 12) {
+                    {
+                        this.state = 115;
+                        this.body();
+                    }
+                }
+                this.state = 118;
+                this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    hideStatement() {
+        let localContext = new HideStatementContext(this.context, this.state);
+        this.enterRule(localContext, 16, plurnkParser.RULE_hideStatement);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 120;
+                this.match(plurnkParser.OPEN_HIDE);
+                this.state = 122;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 42) !== 0)) {
+                    {
+                        this.state = 121;
+                        this.tagOpModifiers();
+                    }
+                }
+                this.state = 124;
+                this.match(plurnkParser.COLON);
+                this.state = 126;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 12) {
+                    {
+                        this.state = 125;
+                        this.body();
+                    }
+                }
+                this.state = 128;
+                this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    sendStatement() {
+        let localContext = new SendStatementContext(this.context, this.state);
+        this.enterRule(localContext, 18, plurnkParser.RULE_sendStatement);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 130;
+                this.match(plurnkParser.OPEN_SEND);
+                this.state = 132;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1 || _la === 3) {
+                    {
+                        this.state = 131;
+                        this.sendModifiers();
+                    }
+                }
+                this.state = 134;
+                this.match(plurnkParser.COLON);
+                this.state = 136;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 12) {
+                    {
+                        this.state = 135;
+                        this.body();
+                    }
+                }
+                this.state = 138;
+                this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    execStatement() {
+        let localContext = new ExecStatementContext(this.context, this.state);
+        this.enterRule(localContext, 20, plurnkParser.RULE_execStatement);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 140;
+                this.match(plurnkParser.OPEN_EXEC);
+                this.state = 142;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 1 || _la === 3) {
+                    {
+                        this.state = 141;
+                        this.execModifiers();
+                    }
+                }
+                this.state = 144;
+                this.match(plurnkParser.COLON);
+                this.state = 146;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 12) {
+                    {
+                        this.state = 145;
+                        this.body();
+                    }
+                }
+                this.state = 148;
+                this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    tagOpModifiers() {
+        let localContext = new TagOpModifiersContext(this.context, this.state);
+        this.enterRule(localContext, 22, plurnkParser.RULE_tagOpModifiers);
+        let _la;
+        try {
+            this.state = 183;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+                case plurnkParser.LBRACKET:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 150;
+                        this.tagSignal();
+                        this.state = 159;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                            case plurnkParser.LPAREN:
+                                {
+                                    this.state = 151;
+                                    this.path();
+                                    this.state = 153;
+                                    this.errorHandler.sync(this);
+                                    _la = this.tokenStream.LA(1);
+                                    if (_la === 5) {
+                                        {
+                                            this.state = 152;
+                                            this.lineMarker();
+                                        }
+                                    }
+                                }
+                                break;
+                            case plurnkParser.L_MARKER:
+                                {
+                                    this.state = 155;
+                                    this.lineMarker();
+                                    this.state = 157;
+                                    this.errorHandler.sync(this);
+                                    _la = this.tokenStream.LA(1);
+                                    if (_la === 3) {
+                                        {
+                                            this.state = 156;
+                                            this.path();
+                                        }
+                                    }
+                                }
+                                break;
+                            case plurnkParser.COLON:
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                    break;
+                case plurnkParser.LPAREN:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 161;
+                        this.path();
+                        this.state = 170;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                            case plurnkParser.LBRACKET:
+                                {
+                                    this.state = 162;
+                                    this.tagSignal();
+                                    this.state = 164;
+                                    this.errorHandler.sync(this);
+                                    _la = this.tokenStream.LA(1);
+                                    if (_la === 5) {
+                                        {
+                                            this.state = 163;
+                                            this.lineMarker();
+                                        }
+                                    }
+                                }
+                                break;
+                            case plurnkParser.L_MARKER:
+                                {
+                                    this.state = 166;
+                                    this.lineMarker();
+                                    this.state = 168;
+                                    this.errorHandler.sync(this);
+                                    _la = this.tokenStream.LA(1);
+                                    if (_la === 1) {
+                                        {
+                                            this.state = 167;
+                                            this.tagSignal();
+                                        }
+                                    }
+                                }
+                                break;
+                            case plurnkParser.COLON:
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                    break;
+                case plurnkParser.L_MARKER:
+                    this.enterOuterAlt(localContext, 3);
+                    {
+                        this.state = 172;
+                        this.lineMarker();
+                        this.state = 181;
+                        this.errorHandler.sync(this);
+                        switch (this.tokenStream.LA(1)) {
+                            case plurnkParser.LBRACKET:
+                                {
+                                    this.state = 173;
+                                    this.tagSignal();
+                                    this.state = 175;
+                                    this.errorHandler.sync(this);
+                                    _la = this.tokenStream.LA(1);
+                                    if (_la === 3) {
+                                        {
+                                            this.state = 174;
+                                            this.path();
+                                        }
+                                    }
+                                }
+                                break;
+                            case plurnkParser.LPAREN:
+                                {
+                                    this.state = 177;
+                                    this.path();
+                                    this.state = 179;
+                                    this.errorHandler.sync(this);
+                                    _la = this.tokenStream.LA(1);
+                                    if (_la === 1) {
+                                        {
+                                            this.state = 178;
+                                            this.tagSignal();
+                                        }
+                                    }
+                                }
+                                break;
+                            case plurnkParser.COLON:
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    sendModifiers() {
+        let localContext = new SendModifiersContext(this.context, this.state);
+        this.enterRule(localContext, 24, plurnkParser.RULE_sendModifiers);
+        let _la;
+        try {
+            this.state = 193;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+                case plurnkParser.LBRACKET:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 185;
+                        this.intSignal();
+                        this.state = 187;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 3) {
+                            {
+                                this.state = 186;
+                                this.path();
+                            }
+                        }
+                    }
+                    break;
+                case plurnkParser.LPAREN:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 189;
+                        this.path();
+                        this.state = 191;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 1) {
+                            {
+                                this.state = 190;
+                                this.intSignal();
+                            }
+                        }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    execModifiers() {
+        let localContext = new ExecModifiersContext(this.context, this.state);
+        this.enterRule(localContext, 26, plurnkParser.RULE_execModifiers);
+        let _la;
+        try {
+            this.state = 203;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+                case plurnkParser.LBRACKET:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 195;
+                        this.identSignal();
+                        this.state = 197;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 3) {
+                            {
+                                this.state = 196;
+                                this.path();
+                            }
+                        }
+                    }
+                    break;
+                case plurnkParser.LPAREN:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 199;
+                        this.path();
+                        this.state = 201;
+                        this.errorHandler.sync(this);
+                        _la = this.tokenStream.LA(1);
+                        if (_la === 1) {
+                            {
+                                this.state = 200;
+                                this.identSignal();
+                            }
+                        }
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    tagSignal() {
+        let localContext = new TagSignalContext(this.context, this.state);
+        this.enterRule(localContext, 28, plurnkParser.RULE_tagSignal);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 205;
+                this.match(plurnkParser.LBRACKET);
+                this.state = 209;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while (_la === 7 || _la === 10) {
+                    {
+                        {
+                            this.state = 206;
+                            _la = this.tokenStream.LA(1);
+                            if (!(_la === 7 || _la === 10)) {
+                                this.errorHandler.recoverInline(this);
+                            }
+                            else {
+                                this.errorHandler.reportMatch(this);
+                                this.consume();
+                            }
+                        }
+                    }
+                    this.state = 211;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 212;
+                this.match(plurnkParser.RBRACKET);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    intSignal() {
+        let localContext = new IntSignalContext(this.context, this.state);
+        this.enterRule(localContext, 30, plurnkParser.RULE_intSignal);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 214;
+                this.match(plurnkParser.LBRACKET);
+                this.state = 216;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 8) {
+                    {
+                        this.state = 215;
+                        this.match(plurnkParser.INT);
+                    }
+                }
+                this.state = 218;
+                this.match(plurnkParser.RBRACKET);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    identSignal() {
+        let localContext = new IdentSignalContext(this.context, this.state);
+        this.enterRule(localContext, 32, plurnkParser.RULE_identSignal);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 220;
+                this.match(plurnkParser.LBRACKET);
+                this.state = 222;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 9) {
+                    {
+                        this.state = 221;
+                        this.match(plurnkParser.IDENT);
+                    }
+                }
+                this.state = 224;
+                this.match(plurnkParser.RBRACKET);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    path() {
+        let localContext = new PathContext(this.context, this.state);
+        this.enterRule(localContext, 34, plurnkParser.RULE_path);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 226;
+                this.match(plurnkParser.LPAREN);
+                this.state = 228;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                if (_la === 11) {
+                    {
+                        this.state = 227;
+                        this.match(plurnkParser.PATH_TEXT);
+                    }
+                }
+                this.state = 230;
+                this.match(plurnkParser.RPAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    lineMarker() {
+        let localContext = new LineMarkerContext(this.context, this.state);
+        this.enterRule(localContext, 36, plurnkParser.RULE_lineMarker);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 232;
+                this.match(plurnkParser.L_MARKER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    body() {
+        let localContext = new BodyContext(this.context, this.state);
+        this.enterRule(localContext, 38, plurnkParser.RULE_body);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 235;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                do {
+                    {
+                        {
+                            this.state = 234;
+                            this.match(plurnkParser.BODY_TEXT);
+                        }
+                    }
+                    this.state = 237;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                } while (_la === 12);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    static _serializedATN = [
+        4, 1, 29, 240, 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, 2, 19, 7, 19, 1, 0,
+        1, 0, 5, 0, 43, 8, 0, 10, 0, 12, 0, 46, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 3, 1, 59, 8, 1, 1, 2, 1, 2, 3, 2, 63, 8, 2, 1, 2, 1, 2, 3, 2, 67, 8, 2, 1, 2,
+        1, 2, 1, 3, 1, 3, 3, 3, 73, 8, 3, 1, 3, 1, 3, 3, 3, 77, 8, 3, 1, 3, 1, 3, 1, 4, 1, 4, 3, 4, 83,
+        8, 4, 1, 4, 1, 4, 3, 4, 87, 8, 4, 1, 4, 1, 4, 1, 5, 1, 5, 3, 5, 93, 8, 5, 1, 5, 1, 5, 3, 5, 97,
+        8, 5, 1, 5, 1, 5, 1, 6, 1, 6, 3, 6, 103, 8, 6, 1, 6, 1, 6, 3, 6, 107, 8, 6, 1, 6, 1, 6, 1, 7,
+        1, 7, 3, 7, 113, 8, 7, 1, 7, 1, 7, 3, 7, 117, 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 3, 8, 123, 8, 8,
+        1, 8, 1, 8, 3, 8, 127, 8, 8, 1, 8, 1, 8, 1, 9, 1, 9, 3, 9, 133, 8, 9, 1, 9, 1, 9, 3, 9, 137,
+        8, 9, 1, 9, 1, 9, 1, 10, 1, 10, 3, 10, 143, 8, 10, 1, 10, 1, 10, 3, 10, 147, 8, 10, 1, 10,
+        1, 10, 1, 11, 1, 11, 1, 11, 3, 11, 154, 8, 11, 1, 11, 1, 11, 3, 11, 158, 8, 11, 3, 11, 160,
+        8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 165, 8, 11, 1, 11, 1, 11, 3, 11, 169, 8, 11, 3, 11, 171,
+        8, 11, 1, 11, 1, 11, 1, 11, 3, 11, 176, 8, 11, 1, 11, 1, 11, 3, 11, 180, 8, 11, 3, 11, 182,
+        8, 11, 3, 11, 184, 8, 11, 1, 12, 1, 12, 3, 12, 188, 8, 12, 1, 12, 1, 12, 3, 12, 192, 8,
+        12, 3, 12, 194, 8, 12, 1, 13, 1, 13, 3, 13, 198, 8, 13, 1, 13, 1, 13, 3, 13, 202, 8, 13,
+        3, 13, 204, 8, 13, 1, 14, 1, 14, 5, 14, 208, 8, 14, 10, 14, 12, 14, 211, 9, 14, 1, 14,
+        1, 14, 1, 15, 1, 15, 3, 15, 217, 8, 15, 1, 15, 1, 15, 1, 16, 1, 16, 3, 16, 223, 8, 16, 1,
+        16, 1, 16, 1, 17, 1, 17, 3, 17, 229, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 4, 19, 236,
+        8, 19, 11, 19, 12, 19, 237, 1, 19, 0, 0, 20, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
+        24, 26, 28, 30, 32, 34, 36, 38, 0, 1, 2, 0, 7, 7, 10, 10, 272, 0, 44, 1, 0, 0, 0, 2, 58,
+        1, 0, 0, 0, 4, 60, 1, 0, 0, 0, 6, 70, 1, 0, 0, 0, 8, 80, 1, 0, 0, 0, 10, 90, 1, 0, 0, 0, 12,
+        100, 1, 0, 0, 0, 14, 110, 1, 0, 0, 0, 16, 120, 1, 0, 0, 0, 18, 130, 1, 0, 0, 0, 20, 140,
+        1, 0, 0, 0, 22, 183, 1, 0, 0, 0, 24, 193, 1, 0, 0, 0, 26, 203, 1, 0, 0, 0, 28, 205, 1, 0,
+        0, 0, 30, 214, 1, 0, 0, 0, 32, 220, 1, 0, 0, 0, 34, 226, 1, 0, 0, 0, 36, 232, 1, 0, 0, 0,
+        38, 235, 1, 0, 0, 0, 40, 43, 3, 2, 1, 0, 41, 43, 5, 14, 0, 0, 42, 40, 1, 0, 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, 47, 1, 0, 0, 0,
+        46, 44, 1, 0, 0, 0, 47, 48, 5, 0, 0, 1, 48, 1, 1, 0, 0, 0, 49, 59, 3, 4, 2, 0, 50, 59, 3, 6,
+        3, 0, 51, 59, 3, 8, 4, 0, 52, 59, 3, 10, 5, 0, 53, 59, 3, 12, 6, 0, 54, 59, 3, 14, 7, 0, 55,
+        59, 3, 16, 8, 0, 56, 59, 3, 18, 9, 0, 57, 59, 3, 20, 10, 0, 58, 49, 1, 0, 0, 0, 58, 50, 1,
+        0, 0, 0, 58, 51, 1, 0, 0, 0, 58, 52, 1, 0, 0, 0, 58, 53, 1, 0, 0, 0, 58, 54, 1, 0, 0, 0, 58,
+        55, 1, 0, 0, 0, 58, 56, 1, 0, 0, 0, 58, 57, 1, 0, 0, 0, 59, 3, 1, 0, 0, 0, 60, 62, 5, 15, 0,
+        0, 61, 63, 3, 22, 11, 0, 62, 61, 1, 0, 0, 0, 62, 63, 1, 0, 0, 0, 63, 64, 1, 0, 0, 0, 64, 66,
+        5, 6, 0, 0, 65, 67, 3, 38, 19, 0, 66, 65, 1, 0, 0, 0, 66, 67, 1, 0, 0, 0, 67, 68, 1, 0, 0,
+        0, 68, 69, 5, 13, 0, 0, 69, 5, 1, 0, 0, 0, 70, 72, 5, 16, 0, 0, 71, 73, 3, 22, 11, 0, 72,
+        71, 1, 0, 0, 0, 72, 73, 1, 0, 0, 0, 73, 74, 1, 0, 0, 0, 74, 76, 5, 6, 0, 0, 75, 77, 3, 38,
+        19, 0, 76, 75, 1, 0, 0, 0, 76, 77, 1, 0, 0, 0, 77, 78, 1, 0, 0, 0, 78, 79, 5, 13, 0, 0, 79,
+        7, 1, 0, 0, 0, 80, 82, 5, 17, 0, 0, 81, 83, 3, 22, 11, 0, 82, 81, 1, 0, 0, 0, 82, 83, 1, 0,
+        0, 0, 83, 84, 1, 0, 0, 0, 84, 86, 5, 6, 0, 0, 85, 87, 3, 38, 19, 0, 86, 85, 1, 0, 0, 0, 86,
+        87, 1, 0, 0, 0, 87, 88, 1, 0, 0, 0, 88, 89, 5, 13, 0, 0, 89, 9, 1, 0, 0, 0, 90, 92, 5, 18,
+        0, 0, 91, 93, 3, 22, 11, 0, 92, 91, 1, 0, 0, 0, 92, 93, 1, 0, 0, 0, 93, 94, 1, 0, 0, 0, 94,
+        96, 5, 6, 0, 0, 95, 97, 3, 38, 19, 0, 96, 95, 1, 0, 0, 0, 96, 97, 1, 0, 0, 0, 97, 98, 1, 0,
+        0, 0, 98, 99, 5, 13, 0, 0, 99, 11, 1, 0, 0, 0, 100, 102, 5, 19, 0, 0, 101, 103, 3, 22, 11,
+        0, 102, 101, 1, 0, 0, 0, 102, 103, 1, 0, 0, 0, 103, 104, 1, 0, 0, 0, 104, 106, 5, 6, 0,
+        0, 105, 107, 3, 38, 19, 0, 106, 105, 1, 0, 0, 0, 106, 107, 1, 0, 0, 0, 107, 108, 1, 0,
+        0, 0, 108, 109, 5, 13, 0, 0, 109, 13, 1, 0, 0, 0, 110, 112, 5, 20, 0, 0, 111, 113, 3, 22,
+        11, 0, 112, 111, 1, 0, 0, 0, 112, 113, 1, 0, 0, 0, 113, 114, 1, 0, 0, 0, 114, 116, 5, 6,
+        0, 0, 115, 117, 3, 38, 19, 0, 116, 115, 1, 0, 0, 0, 116, 117, 1, 0, 0, 0, 117, 118, 1,
+        0, 0, 0, 118, 119, 5, 13, 0, 0, 119, 15, 1, 0, 0, 0, 120, 122, 5, 21, 0, 0, 121, 123, 3,
+        22, 11, 0, 122, 121, 1, 0, 0, 0, 122, 123, 1, 0, 0, 0, 123, 124, 1, 0, 0, 0, 124, 126,
+        5, 6, 0, 0, 125, 127, 3, 38, 19, 0, 126, 125, 1, 0, 0, 0, 126, 127, 1, 0, 0, 0, 127, 128,
+        1, 0, 0, 0, 128, 129, 5, 13, 0, 0, 129, 17, 1, 0, 0, 0, 130, 132, 5, 22, 0, 0, 131, 133,
+        3, 24, 12, 0, 132, 131, 1, 0, 0, 0, 132, 133, 1, 0, 0, 0, 133, 134, 1, 0, 0, 0, 134, 136,
+        5, 6, 0, 0, 135, 137, 3, 38, 19, 0, 136, 135, 1, 0, 0, 0, 136, 137, 1, 0, 0, 0, 137, 138,
+        1, 0, 0, 0, 138, 139, 5, 13, 0, 0, 139, 19, 1, 0, 0, 0, 140, 142, 5, 23, 0, 0, 141, 143,
+        3, 26, 13, 0, 142, 141, 1, 0, 0, 0, 142, 143, 1, 0, 0, 0, 143, 144, 1, 0, 0, 0, 144, 146,
+        5, 6, 0, 0, 145, 147, 3, 38, 19, 0, 146, 145, 1, 0, 0, 0, 146, 147, 1, 0, 0, 0, 147, 148,
+        1, 0, 0, 0, 148, 149, 5, 13, 0, 0, 149, 21, 1, 0, 0, 0, 150, 159, 3, 28, 14, 0, 151, 153,
+        3, 34, 17, 0, 152, 154, 3, 36, 18, 0, 153, 152, 1, 0, 0, 0, 153, 154, 1, 0, 0, 0, 154,
+        160, 1, 0, 0, 0, 155, 157, 3, 36, 18, 0, 156, 158, 3, 34, 17, 0, 157, 156, 1, 0, 0, 0,
+        157, 158, 1, 0, 0, 0, 158, 160, 1, 0, 0, 0, 159, 151, 1, 0, 0, 0, 159, 155, 1, 0, 0, 0,
+        159, 160, 1, 0, 0, 0, 160, 184, 1, 0, 0, 0, 161, 170, 3, 34, 17, 0, 162, 164, 3, 28, 14,
+        0, 163, 165, 3, 36, 18, 0, 164, 163, 1, 0, 0, 0, 164, 165, 1, 0, 0, 0, 165, 171, 1, 0,
+        0, 0, 166, 168, 3, 36, 18, 0, 167, 169, 3, 28, 14, 0, 168, 167, 1, 0, 0, 0, 168, 169,
+        1, 0, 0, 0, 169, 171, 1, 0, 0, 0, 170, 162, 1, 0, 0, 0, 170, 166, 1, 0, 0, 0, 170, 171,
+        1, 0, 0, 0, 171, 184, 1, 0, 0, 0, 172, 181, 3, 36, 18, 0, 173, 175, 3, 28, 14, 0, 174,
+        176, 3, 34, 17, 0, 175, 174, 1, 0, 0, 0, 175, 176, 1, 0, 0, 0, 176, 182, 1, 0, 0, 0, 177,
+        179, 3, 34, 17, 0, 178, 180, 3, 28, 14, 0, 179, 178, 1, 0, 0, 0, 179, 180, 1, 0, 0, 0,
+        180, 182, 1, 0, 0, 0, 181, 173, 1, 0, 0, 0, 181, 177, 1, 0, 0, 0, 181, 182, 1, 0, 0, 0,
+        182, 184, 1, 0, 0, 0, 183, 150, 1, 0, 0, 0, 183, 161, 1, 0, 0, 0, 183, 172, 1, 0, 0, 0,
+        184, 23, 1, 0, 0, 0, 185, 187, 3, 30, 15, 0, 186, 188, 3, 34, 17, 0, 187, 186, 1, 0, 0,
+        0, 187, 188, 1, 0, 0, 0, 188, 194, 1, 0, 0, 0, 189, 191, 3, 34, 17, 0, 190, 192, 3, 30,
+        15, 0, 191, 190, 1, 0, 0, 0, 191, 192, 1, 0, 0, 0, 192, 194, 1, 0, 0, 0, 193, 185, 1, 0,
+        0, 0, 193, 189, 1, 0, 0, 0, 194, 25, 1, 0, 0, 0, 195, 197, 3, 32, 16, 0, 196, 198, 3, 34,
+        17, 0, 197, 196, 1, 0, 0, 0, 197, 198, 1, 0, 0, 0, 198, 204, 1, 0, 0, 0, 199, 201, 3, 34,
+        17, 0, 200, 202, 3, 32, 16, 0, 201, 200, 1, 0, 0, 0, 201, 202, 1, 0, 0, 0, 202, 204, 1,
+        0, 0, 0, 203, 195, 1, 0, 0, 0, 203, 199, 1, 0, 0, 0, 204, 27, 1, 0, 0, 0, 205, 209, 5, 1,
+        0, 0, 206, 208, 7, 0, 0, 0, 207, 206, 1, 0, 0, 0, 208, 211, 1, 0, 0, 0, 209, 207, 1, 0,
+        0, 0, 209, 210, 1, 0, 0, 0, 210, 212, 1, 0, 0, 0, 211, 209, 1, 0, 0, 0, 212, 213, 5, 2,
+        0, 0, 213, 29, 1, 0, 0, 0, 214, 216, 5, 1, 0, 0, 215, 217, 5, 8, 0, 0, 216, 215, 1, 0, 0,
+        0, 216, 217, 1, 0, 0, 0, 217, 218, 1, 0, 0, 0, 218, 219, 5, 2, 0, 0, 219, 31, 1, 0, 0, 0,
+        220, 222, 5, 1, 0, 0, 221, 223, 5, 9, 0, 0, 222, 221, 1, 0, 0, 0, 222, 223, 1, 0, 0, 0,
+        223, 224, 1, 0, 0, 0, 224, 225, 5, 2, 0, 0, 225, 33, 1, 0, 0, 0, 226, 228, 5, 3, 0, 0, 227,
+        229, 5, 11, 0, 0, 228, 227, 1, 0, 0, 0, 228, 229, 1, 0, 0, 0, 229, 230, 1, 0, 0, 0, 230,
+        231, 5, 4, 0, 0, 231, 35, 1, 0, 0, 0, 232, 233, 5, 5, 0, 0, 233, 37, 1, 0, 0, 0, 234, 236,
+        5, 12, 0, 0, 235, 234, 1, 0, 0, 0, 236, 237, 1, 0, 0, 0, 237, 235, 1, 0, 0, 0, 237, 238,
+        1, 0, 0, 0, 238, 39, 1, 0, 0, 0, 42, 42, 44, 58, 62, 66, 72, 76, 82, 86, 92, 96, 102, 106,
+        112, 116, 122, 126, 132, 136, 142, 146, 153, 157, 159, 164, 168, 170, 175, 179,
+        181, 183, 187, 191, 193, 197, 201, 203, 209, 216, 222, 228, 237
+    ];
+    static __ATN;
+    static get _ATN() {
+        if (!plurnkParser.__ATN) {
+            plurnkParser.__ATN = new antlr.ATNDeserializer().deserialize(plurnkParser._serializedATN);
+        }
+        return plurnkParser.__ATN;
+    }
+    static vocabulary = new antlr.Vocabulary(plurnkParser.literalNames, plurnkParser.symbolicNames, []);
+    get vocabulary() {
+        return plurnkParser.vocabulary;
+    }
+    static decisionsToDFA = plurnkParser._ATN.decisionToState.map((ds, index) => new antlr.DFA(ds, index));
+}
+export class DocumentContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    EOF() {
+        return this.getToken(plurnkParser.EOF, 0);
+    }
+    statement(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(StatementContext);
+        }
+        return this.getRuleContext(i, StatementContext);
+    }
+    TEXT(i) {
+        if (i === undefined) {
+            return this.getTokens(plurnkParser.TEXT);
+        }
+        else {
+            return this.getToken(plurnkParser.TEXT, i);
+        }
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_document;
+    }
+    accept(visitor) {
+        if (visitor.visitDocument) {
+            return visitor.visitDocument(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class StatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    findStatement() {
+        return this.getRuleContext(0, FindStatementContext);
+    }
+    readStatement() {
+        return this.getRuleContext(0, ReadStatementContext);
+    }
+    editStatement() {
+        return this.getRuleContext(0, EditStatementContext);
+    }
+    copyStatement() {
+        return this.getRuleContext(0, CopyStatementContext);
+    }
+    moveStatement() {
+        return this.getRuleContext(0, MoveStatementContext);
+    }
+    showStatement() {
+        return this.getRuleContext(0, ShowStatementContext);
+    }
+    hideStatement() {
+        return this.getRuleContext(0, HideStatementContext);
+    }
+    sendStatement() {
+        return this.getRuleContext(0, SendStatementContext);
+    }
+    execStatement() {
+        return this.getRuleContext(0, ExecStatementContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_statement;
+    }
+    accept(visitor) {
+        if (visitor.visitStatement) {
+            return visitor.visitStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class FindStatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    OPEN_FIND() {
+        return this.getToken(plurnkParser.OPEN_FIND, 0);
+    }
+    COLON() {
+        return this.getToken(plurnkParser.COLON, 0);
+    }
+    CLOSE_TAG() {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0);
+    }
+    tagOpModifiers() {
+        return this.getRuleContext(0, TagOpModifiersContext);
+    }
+    body() {
+        return this.getRuleContext(0, BodyContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_findStatement;
+    }
+    accept(visitor) {
+        if (visitor.visitFindStatement) {
+            return visitor.visitFindStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ReadStatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    OPEN_READ() {
+        return this.getToken(plurnkParser.OPEN_READ, 0);
+    }
+    COLON() {
+        return this.getToken(plurnkParser.COLON, 0);
+    }
+    CLOSE_TAG() {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0);
+    }
+    tagOpModifiers() {
+        return this.getRuleContext(0, TagOpModifiersContext);
+    }
+    body() {
+        return this.getRuleContext(0, BodyContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_readStatement;
+    }
+    accept(visitor) {
+        if (visitor.visitReadStatement) {
+            return visitor.visitReadStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class EditStatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    OPEN_EDIT() {
+        return this.getToken(plurnkParser.OPEN_EDIT, 0);
+    }
+    COLON() {
+        return this.getToken(plurnkParser.COLON, 0);
+    }
+    CLOSE_TAG() {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0);
+    }
+    tagOpModifiers() {
+        return this.getRuleContext(0, TagOpModifiersContext);
+    }
+    body() {
+        return this.getRuleContext(0, BodyContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_editStatement;
+    }
+    accept(visitor) {
+        if (visitor.visitEditStatement) {
+            return visitor.visitEditStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class CopyStatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    OPEN_COPY() {
+        return this.getToken(plurnkParser.OPEN_COPY, 0);
+    }
+    COLON() {
+        return this.getToken(plurnkParser.COLON, 0);
+    }
+    CLOSE_TAG() {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0);
+    }
+    tagOpModifiers() {
+        return this.getRuleContext(0, TagOpModifiersContext);
+    }
+    body() {
+        return this.getRuleContext(0, BodyContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_copyStatement;
+    }
+    accept(visitor) {
+        if (visitor.visitCopyStatement) {
+            return visitor.visitCopyStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class MoveStatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    OPEN_MOVE() {
+        return this.getToken(plurnkParser.OPEN_MOVE, 0);
+    }
+    COLON() {
+        return this.getToken(plurnkParser.COLON, 0);
+    }
+    CLOSE_TAG() {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0);
+    }
+    tagOpModifiers() {
+        return this.getRuleContext(0, TagOpModifiersContext);
+    }
+    body() {
+        return this.getRuleContext(0, BodyContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_moveStatement;
+    }
+    accept(visitor) {
+        if (visitor.visitMoveStatement) {
+            return visitor.visitMoveStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ShowStatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    OPEN_SHOW() {
+        return this.getToken(plurnkParser.OPEN_SHOW, 0);
+    }
+    COLON() {
+        return this.getToken(plurnkParser.COLON, 0);
+    }
+    CLOSE_TAG() {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0);
+    }
+    tagOpModifiers() {
+        return this.getRuleContext(0, TagOpModifiersContext);
+    }
+    body() {
+        return this.getRuleContext(0, BodyContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_showStatement;
+    }
+    accept(visitor) {
+        if (visitor.visitShowStatement) {
+            return visitor.visitShowStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class HideStatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    OPEN_HIDE() {
+        return this.getToken(plurnkParser.OPEN_HIDE, 0);
+    }
+    COLON() {
+        return this.getToken(plurnkParser.COLON, 0);
+    }
+    CLOSE_TAG() {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0);
+    }
+    tagOpModifiers() {
+        return this.getRuleContext(0, TagOpModifiersContext);
+    }
+    body() {
+        return this.getRuleContext(0, BodyContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_hideStatement;
+    }
+    accept(visitor) {
+        if (visitor.visitHideStatement) {
+            return visitor.visitHideStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class SendStatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    OPEN_SEND() {
+        return this.getToken(plurnkParser.OPEN_SEND, 0);
+    }
+    COLON() {
+        return this.getToken(plurnkParser.COLON, 0);
+    }
+    CLOSE_TAG() {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0);
+    }
+    sendModifiers() {
+        return this.getRuleContext(0, SendModifiersContext);
+    }
+    body() {
+        return this.getRuleContext(0, BodyContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_sendStatement;
+    }
+    accept(visitor) {
+        if (visitor.visitSendStatement) {
+            return visitor.visitSendStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ExecStatementContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    OPEN_EXEC() {
+        return this.getToken(plurnkParser.OPEN_EXEC, 0);
+    }
+    COLON() {
+        return this.getToken(plurnkParser.COLON, 0);
+    }
+    CLOSE_TAG() {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0);
+    }
+    execModifiers() {
+        return this.getRuleContext(0, ExecModifiersContext);
+    }
+    body() {
+        return this.getRuleContext(0, BodyContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_execStatement;
+    }
+    accept(visitor) {
+        if (visitor.visitExecStatement) {
+            return visitor.visitExecStatement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class TagOpModifiersContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    tagSignal() {
+        return this.getRuleContext(0, TagSignalContext);
+    }
+    path() {
+        return this.getRuleContext(0, PathContext);
+    }
+    lineMarker() {
+        return this.getRuleContext(0, LineMarkerContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_tagOpModifiers;
+    }
+    accept(visitor) {
+        if (visitor.visitTagOpModifiers) {
+            return visitor.visitTagOpModifiers(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class SendModifiersContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    intSignal() {
+        return this.getRuleContext(0, IntSignalContext);
+    }
+    path() {
+        return this.getRuleContext(0, PathContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_sendModifiers;
+    }
+    accept(visitor) {
+        if (visitor.visitSendModifiers) {
+            return visitor.visitSendModifiers(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ExecModifiersContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    identSignal() {
+        return this.getRuleContext(0, IdentSignalContext);
+    }
+    path() {
+        return this.getRuleContext(0, PathContext);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_execModifiers;
+    }
+    accept(visitor) {
+        if (visitor.visitExecModifiers) {
+            return visitor.visitExecModifiers(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class TagSignalContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    LBRACKET() {
+        return this.getToken(plurnkParser.LBRACKET, 0);
+    }
+    RBRACKET() {
+        return this.getToken(plurnkParser.RBRACKET, 0);
+    }
+    TAG(i) {
+        if (i === undefined) {
+            return this.getTokens(plurnkParser.TAG);
+        }
+        else {
+            return this.getToken(plurnkParser.TAG, i);
+        }
+    }
+    COMMA(i) {
+        if (i === undefined) {
+            return this.getTokens(plurnkParser.COMMA);
+        }
+        else {
+            return this.getToken(plurnkParser.COMMA, i);
+        }
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_tagSignal;
+    }
+    accept(visitor) {
+        if (visitor.visitTagSignal) {
+            return visitor.visitTagSignal(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class IntSignalContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    LBRACKET() {
+        return this.getToken(plurnkParser.LBRACKET, 0);
+    }
+    RBRACKET() {
+        return this.getToken(plurnkParser.RBRACKET, 0);
+    }
+    INT() {
+        return this.getToken(plurnkParser.INT, 0);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_intSignal;
+    }
+    accept(visitor) {
+        if (visitor.visitIntSignal) {
+            return visitor.visitIntSignal(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class IdentSignalContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    LBRACKET() {
+        return this.getToken(plurnkParser.LBRACKET, 0);
+    }
+    RBRACKET() {
+        return this.getToken(plurnkParser.RBRACKET, 0);
+    }
+    IDENT() {
+        return this.getToken(plurnkParser.IDENT, 0);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_identSignal;
+    }
+    accept(visitor) {
+        if (visitor.visitIdentSignal) {
+            return visitor.visitIdentSignal(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class PathContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    LPAREN() {
+        return this.getToken(plurnkParser.LPAREN, 0);
+    }
+    RPAREN() {
+        return this.getToken(plurnkParser.RPAREN, 0);
+    }
+    PATH_TEXT() {
+        return this.getToken(plurnkParser.PATH_TEXT, 0);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_path;
+    }
+    accept(visitor) {
+        if (visitor.visitPath) {
+            return visitor.visitPath(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class LineMarkerContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    L_MARKER() {
+        return this.getToken(plurnkParser.L_MARKER, 0);
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_lineMarker;
+    }
+    accept(visitor) {
+        if (visitor.visitLineMarker) {
+            return visitor.visitLineMarker(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class BodyContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    BODY_TEXT(i) {
+        if (i === undefined) {
+            return this.getTokens(plurnkParser.BODY_TEXT);
+        }
+        else {
+            return this.getToken(plurnkParser.BODY_TEXT, i);
+        }
+    }
+    get ruleIndex() {
+        return plurnkParser.RULE_body;
+    }
+    accept(visitor) {
+        if (visitor.visitBody) {
+            return visitor.visitBody(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+//# sourceMappingURL=plurnkParser.js.map