@malloydata/malloy 0.0.70-dev230810160240 → 0.0.70

package/dist/lang/lib/Malloy/MalloyTagParser.js

@@ -0,0 +1,1104 @@
+"use strict";
+// Generated from MalloyTag.g4 by ANTLR 4.9.0-SNAPSHOT
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertiesContext = exports.ArrayValueContext = exports.ReferenceContext = exports.ArrayElementContext = exports.EqValueContext = exports.PropNameContext = exports.StringContext = exports.TagDefContext = exports.TagUpdatePropertiesContext = exports.TagReplacePropertiesContext = exports.TagEqContext = exports.TagSpecContext = exports.TagLineContext = exports.MalloyTagParser = void 0;
+const ATN_1 = require("antlr4ts/atn/ATN");
+const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
+const FailedPredicateException_1 = require("antlr4ts/FailedPredicateException");
+const NoViableAltException_1 = require("antlr4ts/NoViableAltException");
+const Parser_1 = require("antlr4ts/Parser");
+const ParserRuleContext_1 = require("antlr4ts/ParserRuleContext");
+const ParserATNSimulator_1 = require("antlr4ts/atn/ParserATNSimulator");
+const RecognitionException_1 = require("antlr4ts/RecognitionException");
+const Token_1 = require("antlr4ts/Token");
+const VocabularyImpl_1 = require("antlr4ts/VocabularyImpl");
+const Utils = __importStar(require("antlr4ts/misc/Utils"));
+class MalloyTagParser extends Parser_1.Parser {
+    constructor(input) {
+        super(input);
+        this._interp = new ParserATNSimulator_1.ParserATNSimulator(MalloyTagParser._ATN, this);
+    }
+    // @Override
+    // @NotNull
+    get vocabulary() {
+        return MalloyTagParser.VOCABULARY;
+    }
+    // tslint:enable:no-trailing-whitespace
+    // @Override
+    get grammarFileName() { return "MalloyTag.g4"; }
+    // @Override
+    get ruleNames() { return MalloyTagParser.ruleNames; }
+    // @Override
+    get serializedATN() { return MalloyTagParser._serializedATN; }
+    createFailedPredicateException(predicate, message) {
+        return new FailedPredicateException_1.FailedPredicateException(this, predicate, message);
+    }
+    // @RuleVersion(0)
+    tagLine() {
+        let _localctx = new TagLineContext(this._ctx, this.state);
+        this.enterRule(_localctx, 0, MalloyTagParser.RULE_tagLine);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 21;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << MalloyTagParser.MINUS) | (1 << MalloyTagParser.SQ_STRING) | (1 << MalloyTagParser.DQ_STRING) | (1 << MalloyTagParser.BARE_STRING))) !== 0)) {
+                    {
+                        {
+                            this.state = 18;
+                            this.tagSpec();
+                        }
+                    }
+                    this.state = 23;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 24;
+                this.match(MalloyTagParser.EOF);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    tagSpec() {
+        let _localctx = new TagSpecContext(this._ctx, this.state);
+        this.enterRule(_localctx, 2, MalloyTagParser.RULE_tagSpec);
+        let _la;
+        try {
+            this.state = 46;
+            this._errHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this._input, 4, this._ctx)) {
+                case 1:
+                    _localctx = new TagEqContext(_localctx);
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 26;
+                        this.propName();
+                        this.state = 27;
+                        this.match(MalloyTagParser.EQ);
+                        this.state = 28;
+                        this.eqValue();
+                        this.state = 30;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if (_la === MalloyTagParser.PR_BEG) {
+                            {
+                                this.state = 29;
+                                this.properties();
+                            }
+                        }
+                    }
+                    break;
+                case 2:
+                    _localctx = new TagReplacePropertiesContext(_localctx);
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 32;
+                        this.propName();
+                        this.state = 33;
+                        this.match(MalloyTagParser.EQ);
+                        this.state = 35;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if (_la === MalloyTagParser.DOTTY) {
+                            {
+                                this.state = 34;
+                                this.match(MalloyTagParser.DOTTY);
+                            }
+                        }
+                        this.state = 37;
+                        this.properties();
+                    }
+                    break;
+                case 3:
+                    _localctx = new TagUpdatePropertiesContext(_localctx);
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 39;
+                        this.propName();
+                        this.state = 40;
+                        this.properties();
+                    }
+                    break;
+                case 4:
+                    _localctx = new TagDefContext(_localctx);
+                    this.enterOuterAlt(_localctx, 4);
+                    {
+                        this.state = 43;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if (_la === MalloyTagParser.MINUS) {
+                            {
+                                this.state = 42;
+                                this.match(MalloyTagParser.MINUS);
+                            }
+                        }
+                        this.state = 45;
+                        this.propName();
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    string() {
+        let _localctx = new StringContext(this._ctx, this.state);
+        this.enterRule(_localctx, 4, MalloyTagParser.RULE_string);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 48;
+                _la = this._input.LA(1);
+                if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << MalloyTagParser.SQ_STRING) | (1 << MalloyTagParser.DQ_STRING) | (1 << MalloyTagParser.BARE_STRING))) !== 0))) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    if (this._input.LA(1) === Token_1.Token.EOF) {
+                        this.matchedEOF = true;
+                    }
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    propName() {
+        let _localctx = new PropNameContext(this._ctx, this.state);
+        this.enterRule(_localctx, 6, MalloyTagParser.RULE_propName);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 50;
+                this.string();
+                this.state = 55;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === MalloyTagParser.DOT) {
+                    {
+                        {
+                            this.state = 51;
+                            this.match(MalloyTagParser.DOT);
+                            this.state = 52;
+                            this.string();
+                        }
+                    }
+                    this.state = 57;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    eqValue() {
+        let _localctx = new EqValueContext(this._ctx, this.state);
+        this.enterRule(_localctx, 8, MalloyTagParser.RULE_eqValue);
+        try {
+            this.state = 61;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case MalloyTagParser.SQ_STRING:
+                case MalloyTagParser.DQ_STRING:
+                case MalloyTagParser.BARE_STRING:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 58;
+                        this.string();
+                    }
+                    break;
+                case MalloyTagParser.AR_BEG:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 59;
+                        this.arrayValue();
+                    }
+                    break;
+                case MalloyTagParser.RF_BEG:
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 60;
+                        this.reference();
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    arrayElement() {
+        let _localctx = new ArrayElementContext(this._ctx, this.state);
+        this.enterRule(_localctx, 10, MalloyTagParser.RULE_arrayElement);
+        let _la;
+        try {
+            this.state = 70;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case MalloyTagParser.SQ_STRING:
+                case MalloyTagParser.DQ_STRING:
+                case MalloyTagParser.BARE_STRING:
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 63;
+                        this.string();
+                        this.state = 65;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        if (_la === MalloyTagParser.PR_BEG) {
+                            {
+                                this.state = 64;
+                                this.properties();
+                            }
+                        }
+                    }
+                    break;
+                case MalloyTagParser.PR_BEG:
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 67;
+                        this.properties();
+                    }
+                    break;
+                case MalloyTagParser.AR_BEG:
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 68;
+                        this.arrayValue();
+                    }
+                    break;
+                case MalloyTagParser.RF_BEG:
+                    this.enterOuterAlt(_localctx, 4);
+                    {
+                        this.state = 69;
+                        this.reference();
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    reference() {
+        let _localctx = new ReferenceContext(this._ctx, this.state);
+        this.enterRule(_localctx, 12, MalloyTagParser.RULE_reference);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 72;
+                this.match(MalloyTagParser.RF_BEG);
+                this.state = 73;
+                this.propName();
+                this.state = 74;
+                this.match(MalloyTagParser.RF_END);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    arrayValue() {
+        let _localctx = new ArrayValueContext(this._ctx, this.state);
+        this.enterRule(_localctx, 14, MalloyTagParser.RULE_arrayValue);
+        let _la;
+        try {
+            let _alt;
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 76;
+                this.match(MalloyTagParser.AR_BEG);
+                this.state = 77;
+                this.arrayElement();
+                this.state = 82;
+                this._errHandler.sync(this);
+                _alt = this.interpreter.adaptivePredict(this._input, 9, this._ctx);
+                while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        {
+                            {
+                                this.state = 78;
+                                this.match(MalloyTagParser.COMMA);
+                                this.state = 79;
+                                this.arrayElement();
+                            }
+                        }
+                    }
+                    this.state = 84;
+                    this._errHandler.sync(this);
+                    _alt = this.interpreter.adaptivePredict(this._input, 9, this._ctx);
+                }
+                this.state = 86;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === MalloyTagParser.COMMA) {
+                    {
+                        this.state = 85;
+                        this.match(MalloyTagParser.COMMA);
+                    }
+                }
+                this.state = 88;
+                this.match(MalloyTagParser.AR_END);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    // @RuleVersion(0)
+    properties() {
+        let _localctx = new PropertiesContext(this._ctx, this.state);
+        this.enterRule(_localctx, 16, MalloyTagParser.RULE_properties);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 90;
+                this.match(MalloyTagParser.PR_BEG);
+                this.state = 98;
+                this._errHandler.sync(this);
+                switch (this._input.LA(1)) {
+                    case MalloyTagParser.DOTTY:
+                        {
+                            this.state = 91;
+                            this.match(MalloyTagParser.DOTTY);
+                        }
+                        break;
+                    case MalloyTagParser.MINUS:
+                    case MalloyTagParser.PR_END:
+                    case MalloyTagParser.SQ_STRING:
+                    case MalloyTagParser.DQ_STRING:
+                    case MalloyTagParser.BARE_STRING:
+                        {
+                            {
+                                this.state = 95;
+                                this._errHandler.sync(this);
+                                _la = this._input.LA(1);
+                                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << MalloyTagParser.MINUS) | (1 << MalloyTagParser.SQ_STRING) | (1 << MalloyTagParser.DQ_STRING) | (1 << MalloyTagParser.BARE_STRING))) !== 0)) {
+                                    {
+                                        {
+                                            this.state = 92;
+                                            this.tagSpec();
+                                        }
+                                    }
+                                    this.state = 97;
+                                    this._errHandler.sync(this);
+                                    _la = this._input.LA(1);
+                                }
+                            }
+                        }
+                        break;
+                    default:
+                        throw new NoViableAltException_1.NoViableAltException(this);
+                }
+                this.state = 100;
+                this.match(MalloyTagParser.PR_END);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.RecognitionException) {
+                _localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return _localctx;
+    }
+    static get _ATN() {
+        if (!MalloyTagParser.__ATN) {
+            MalloyTagParser.__ATN = new ATNDeserializer_1.ATNDeserializer().deserialize(Utils.toCharArray(MalloyTagParser._serializedATN));
+        }
+        return MalloyTagParser.__ATN;
+    }
+}
+exports.MalloyTagParser = MalloyTagParser;
+MalloyTagParser.DOTTY = 1;
+MalloyTagParser.DOT = 2;
+MalloyTagParser.MINUS = 3;
+MalloyTagParser.EQ = 4;
+MalloyTagParser.RF_BEG = 5;
+MalloyTagParser.RF_END = 6;
+MalloyTagParser.PR_BEG = 7;
+MalloyTagParser.PR_END = 8;
+MalloyTagParser.AR_BEG = 9;
+MalloyTagParser.COMMA = 10;
+MalloyTagParser.AR_END = 11;
+MalloyTagParser.SQ_STRING = 12;
+MalloyTagParser.DQ_STRING = 13;
+MalloyTagParser.BARE_STRING = 14;
+MalloyTagParser.COMMENT = 15;
+MalloyTagParser.WHITE_SPACE = 16;
+MalloyTagParser.UNEXPECTED_CHAR = 17;
+MalloyTagParser.RULE_tagLine = 0;
+MalloyTagParser.RULE_tagSpec = 1;
+MalloyTagParser.RULE_string = 2;
+MalloyTagParser.RULE_propName = 3;
+MalloyTagParser.RULE_eqValue = 4;
+MalloyTagParser.RULE_arrayElement = 5;
+MalloyTagParser.RULE_reference = 6;
+MalloyTagParser.RULE_arrayValue = 7;
+MalloyTagParser.RULE_properties = 8;
+// tslint:disable:no-trailing-whitespace
+MalloyTagParser.ruleNames = [
+    "tagLine", "tagSpec", "string", "propName", "eqValue", "arrayElement",
+    "reference", "arrayValue", "properties",
+];
+MalloyTagParser._LITERAL_NAMES = [
+    undefined, "'...'", "'.'", "'-'", "'='", "'$('", "')'", "'{'", "'}'",
+    "'['", "','", "']'",
+];
+MalloyTagParser._SYMBOLIC_NAMES = [
+    undefined, "DOTTY", "DOT", "MINUS", "EQ", "RF_BEG", "RF_END", "PR_BEG",
+    "PR_END", "AR_BEG", "COMMA", "AR_END", "SQ_STRING", "DQ_STRING", "BARE_STRING",
+    "COMMENT", "WHITE_SPACE", "UNEXPECTED_CHAR",
+];
+MalloyTagParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(MalloyTagParser._LITERAL_NAMES, MalloyTagParser._SYMBOLIC_NAMES, []);
+MalloyTagParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x13i\x04\x02" +
+    "\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
+    "\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x03\x02\x07\x02\x16\n\x02\f\x02\x0E" +
+    "\x02\x19\v\x02\x03\x02\x03\x02\x03\x03\x03\x03\x03\x03\x03\x03\x05\x03" +
+    "!\n\x03\x03\x03\x03\x03\x03\x03\x05\x03&\n\x03\x03\x03\x03\x03\x03\x03" +
+    "\x03\x03\x03\x03\x03\x03\x05\x03.\n\x03\x03\x03\x05\x031\n\x03\x03\x04" +
+    "\x03\x04\x03\x05\x03\x05\x03\x05\x07\x058\n\x05\f\x05\x0E\x05;\v\x05\x03" +
+    "\x06\x03\x06\x03\x06\x05\x06@\n\x06\x03\x07\x03\x07\x05\x07D\n\x07\x03" +
+    "\x07\x03\x07\x03\x07\x05\x07I\n\x07\x03\b\x03\b\x03\b\x03\b\x03\t\x03" +
+    "\t\x03\t\x03\t\x07\tS\n\t\f\t\x0E\tV\v\t\x03\t\x05\tY\n\t\x03\t\x03\t" +
+    "\x03\n\x03\n\x03\n\x07\n`\n\n\f\n\x0E\nc\v\n\x05\ne\n\n\x03\n\x03\n\x03" +
+    "\n\x02\x02\x02\v\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E\x02\x10" +
+    "\x02\x12\x02\x02\x03\x03\x02\x0E\x10\x02q\x02\x17\x03\x02\x02\x02\x04" +
+    "0\x03\x02\x02\x02\x062\x03\x02\x02\x02\b4\x03\x02\x02\x02\n?\x03\x02\x02" +
+    "\x02\fH\x03\x02\x02\x02\x0EJ\x03\x02\x02\x02\x10N\x03\x02\x02\x02\x12" +
+    "\\\x03\x02\x02\x02\x14\x16\x05\x04\x03\x02\x15\x14\x03\x02\x02\x02\x16" +
+    "\x19\x03\x02\x02\x02\x17\x15\x03\x02\x02\x02\x17\x18\x03\x02\x02\x02\x18" +
+    "\x1A\x03\x02\x02\x02\x19\x17\x03\x02\x02\x02\x1A\x1B\x07\x02\x02\x03\x1B" +
+    "\x03\x03\x02\x02\x02\x1C\x1D\x05\b\x05\x02\x1D\x1E\x07\x06\x02\x02\x1E" +
+    " \x05\n\x06\x02\x1F!\x05\x12\n\x02 \x1F\x03\x02\x02\x02 !\x03\x02\x02" +
+    "\x02!1\x03\x02\x02\x02\"#\x05\b\x05\x02#%\x07\x06\x02\x02$&\x07\x03\x02" +
+    "\x02%$\x03\x02\x02\x02%&\x03\x02\x02\x02&\'\x03\x02\x02\x02\'(\x05\x12" +
+    "\n\x02(1\x03\x02\x02\x02)*\x05\b\x05\x02*+\x05\x12\n\x02+1\x03\x02\x02" +
+    "\x02,.\x07\x05\x02\x02-,\x03\x02\x02\x02-.\x03\x02\x02\x02./\x03\x02\x02" +
+    "\x02/1\x05\b\x05\x020\x1C\x03\x02\x02\x020\"\x03\x02\x02\x020)\x03\x02" +
+    "\x02\x020-\x03\x02\x02\x021\x05\x03\x02\x02\x0223\t\x02\x02\x023\x07\x03" +
+    "\x02\x02\x0249\x05\x06\x04\x0256\x07\x04\x02\x0268\x05\x06\x04\x0275\x03" +
+    "\x02\x02\x028;\x03\x02\x02\x0297\x03\x02\x02\x029:\x03\x02\x02\x02:\t" +
+    "\x03\x02\x02\x02;9\x03\x02\x02\x02<@\x05\x06\x04\x02=@\x05\x10\t\x02>" +
+    "@\x05\x0E\b\x02?<\x03\x02\x02\x02?=\x03\x02\x02\x02?>\x03\x02\x02\x02" +
+    "@\v\x03\x02\x02\x02AC\x05\x06\x04\x02BD\x05\x12\n\x02CB\x03\x02\x02\x02" +
+    "CD\x03\x02\x02\x02DI\x03\x02\x02\x02EI\x05\x12\n\x02FI\x05\x10\t\x02G" +
+    "I\x05\x0E\b\x02HA\x03\x02\x02\x02HE\x03\x02\x02\x02HF\x03\x02\x02\x02" +
+    "HG\x03\x02\x02\x02I\r\x03\x02\x02\x02JK\x07\x07\x02\x02KL\x05\b\x05\x02" +
+    "LM\x07\b\x02\x02M\x0F\x03\x02\x02\x02NO\x07\v\x02\x02OT\x05\f\x07\x02" +
+    "PQ\x07\f\x02\x02QS\x05\f\x07\x02RP\x03\x02\x02\x02SV\x03\x02\x02\x02T" +
+    "R\x03\x02\x02\x02TU\x03\x02\x02\x02UX\x03\x02\x02\x02VT\x03\x02\x02\x02" +
+    "WY\x07\f\x02\x02XW\x03\x02\x02\x02XY\x03\x02\x02\x02YZ\x03\x02\x02\x02" +
+    "Z[\x07\r\x02\x02[\x11\x03\x02\x02\x02\\d\x07\t\x02\x02]e\x07\x03\x02\x02" +
+    "^`\x05\x04\x03\x02_^\x03\x02\x02\x02`c\x03\x02\x02\x02a_\x03\x02\x02\x02" +
+    "ab\x03\x02\x02\x02be\x03\x02\x02\x02ca\x03\x02\x02\x02d]\x03\x02\x02\x02" +
+    "da\x03\x02\x02\x02ef\x03\x02\x02\x02fg\x07\n\x02\x02g\x13\x03\x02\x02" +
+    "\x02\x0F\x17 %-09?CHTXad";
+class TagLineContext extends ParserRuleContext_1.ParserRuleContext {
+    EOF() { return this.getToken(MalloyTagParser.EOF, 0); }
+    tagSpec(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(TagSpecContext);
+        }
+        else {
+            return this.getRuleContext(i, TagSpecContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return MalloyTagParser.RULE_tagLine; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTagLine) {
+            listener.enterTagLine(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTagLine) {
+            listener.exitTagLine(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTagLine) {
+            return visitor.visitTagLine(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TagLineContext = TagLineContext;
+class TagSpecContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return MalloyTagParser.RULE_tagSpec; }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+exports.TagSpecContext = TagSpecContext;
+class TagEqContext extends TagSpecContext {
+    propName() {
+        return this.getRuleContext(0, PropNameContext);
+    }
+    EQ() { return this.getToken(MalloyTagParser.EQ, 0); }
+    eqValue() {
+        return this.getRuleContext(0, EqValueContext);
+    }
+    properties() {
+        return this.tryGetRuleContext(0, PropertiesContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTagEq) {
+            listener.enterTagEq(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTagEq) {
+            listener.exitTagEq(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTagEq) {
+            return visitor.visitTagEq(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TagEqContext = TagEqContext;
+class TagReplacePropertiesContext extends TagSpecContext {
+    propName() {
+        return this.getRuleContext(0, PropNameContext);
+    }
+    EQ() { return this.getToken(MalloyTagParser.EQ, 0); }
+    properties() {
+        return this.getRuleContext(0, PropertiesContext);
+    }
+    DOTTY() { return this.tryGetToken(MalloyTagParser.DOTTY, 0); }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTagReplaceProperties) {
+            listener.enterTagReplaceProperties(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTagReplaceProperties) {
+            listener.exitTagReplaceProperties(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTagReplaceProperties) {
+            return visitor.visitTagReplaceProperties(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TagReplacePropertiesContext = TagReplacePropertiesContext;
+class TagUpdatePropertiesContext extends TagSpecContext {
+    propName() {
+        return this.getRuleContext(0, PropNameContext);
+    }
+    properties() {
+        return this.getRuleContext(0, PropertiesContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTagUpdateProperties) {
+            listener.enterTagUpdateProperties(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTagUpdateProperties) {
+            listener.exitTagUpdateProperties(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTagUpdateProperties) {
+            return visitor.visitTagUpdateProperties(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TagUpdatePropertiesContext = TagUpdatePropertiesContext;
+class TagDefContext extends TagSpecContext {
+    propName() {
+        return this.getRuleContext(0, PropNameContext);
+    }
+    MINUS() { return this.tryGetToken(MalloyTagParser.MINUS, 0); }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterTagDef) {
+            listener.enterTagDef(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitTagDef) {
+            listener.exitTagDef(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitTagDef) {
+            return visitor.visitTagDef(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.TagDefContext = TagDefContext;
+class StringContext extends ParserRuleContext_1.ParserRuleContext {
+    SQ_STRING() { return this.tryGetToken(MalloyTagParser.SQ_STRING, 0); }
+    DQ_STRING() { return this.tryGetToken(MalloyTagParser.DQ_STRING, 0); }
+    BARE_STRING() { return this.tryGetToken(MalloyTagParser.BARE_STRING, 0); }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return MalloyTagParser.RULE_string; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterString) {
+            listener.enterString(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitString) {
+            listener.exitString(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitString) {
+            return visitor.visitString(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.StringContext = StringContext;
+class PropNameContext extends ParserRuleContext_1.ParserRuleContext {
+    string(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(StringContext);
+        }
+        else {
+            return this.getRuleContext(i, StringContext);
+        }
+    }
+    DOT(i) {
+        if (i === undefined) {
+            return this.getTokens(MalloyTagParser.DOT);
+        }
+        else {
+            return this.getToken(MalloyTagParser.DOT, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return MalloyTagParser.RULE_propName; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterPropName) {
+            listener.enterPropName(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitPropName) {
+            listener.exitPropName(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitPropName) {
+            return visitor.visitPropName(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.PropNameContext = PropNameContext;
+class EqValueContext extends ParserRuleContext_1.ParserRuleContext {
+    string() {
+        return this.tryGetRuleContext(0, StringContext);
+    }
+    arrayValue() {
+        return this.tryGetRuleContext(0, ArrayValueContext);
+    }
+    reference() {
+        return this.tryGetRuleContext(0, ReferenceContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return MalloyTagParser.RULE_eqValue; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterEqValue) {
+            listener.enterEqValue(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitEqValue) {
+            listener.exitEqValue(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitEqValue) {
+            return visitor.visitEqValue(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.EqValueContext = EqValueContext;
+class ArrayElementContext extends ParserRuleContext_1.ParserRuleContext {
+    string() {
+        return this.tryGetRuleContext(0, StringContext);
+    }
+    properties() {
+        return this.tryGetRuleContext(0, PropertiesContext);
+    }
+    arrayValue() {
+        return this.tryGetRuleContext(0, ArrayValueContext);
+    }
+    reference() {
+        return this.tryGetRuleContext(0, ReferenceContext);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return MalloyTagParser.RULE_arrayElement; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterArrayElement) {
+            listener.enterArrayElement(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitArrayElement) {
+            listener.exitArrayElement(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitArrayElement) {
+            return visitor.visitArrayElement(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ArrayElementContext = ArrayElementContext;
+class ReferenceContext extends ParserRuleContext_1.ParserRuleContext {
+    RF_BEG() { return this.getToken(MalloyTagParser.RF_BEG, 0); }
+    propName() {
+        return this.getRuleContext(0, PropNameContext);
+    }
+    RF_END() { return this.getToken(MalloyTagParser.RF_END, 0); }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return MalloyTagParser.RULE_reference; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterReference) {
+            listener.enterReference(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitReference) {
+            listener.exitReference(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitReference) {
+            return visitor.visitReference(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ReferenceContext = ReferenceContext;
+class ArrayValueContext extends ParserRuleContext_1.ParserRuleContext {
+    AR_BEG() { return this.getToken(MalloyTagParser.AR_BEG, 0); }
+    arrayElement(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ArrayElementContext);
+        }
+        else {
+            return this.getRuleContext(i, ArrayElementContext);
+        }
+    }
+    AR_END() { return this.getToken(MalloyTagParser.AR_END, 0); }
+    COMMA(i) {
+        if (i === undefined) {
+            return this.getTokens(MalloyTagParser.COMMA);
+        }
+        else {
+            return this.getToken(MalloyTagParser.COMMA, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return MalloyTagParser.RULE_arrayValue; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterArrayValue) {
+            listener.enterArrayValue(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitArrayValue) {
+            listener.exitArrayValue(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitArrayValue) {
+            return visitor.visitArrayValue(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ArrayValueContext = ArrayValueContext;
+class PropertiesContext extends ParserRuleContext_1.ParserRuleContext {
+    PR_BEG() { return this.getToken(MalloyTagParser.PR_BEG, 0); }
+    PR_END() { return this.getToken(MalloyTagParser.PR_END, 0); }
+    DOTTY() { return this.tryGetToken(MalloyTagParser.DOTTY, 0); }
+    tagSpec(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(TagSpecContext);
+        }
+        else {
+            return this.getRuleContext(i, TagSpecContext);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() { return MalloyTagParser.RULE_properties; }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterProperties) {
+            listener.enterProperties(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitProperties) {
+            listener.exitProperties(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitProperties) {
+            return visitor.visitProperties(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.PropertiesContext = PropertiesContext;
+//# sourceMappingURL=MalloyTagParser.js.map