@plurnk/plurnk-mimetypes-text-clojure 0.2.0

package/dist/generated/ClojureParser.js

@@ -0,0 +1,2475 @@
+import * as antlr from "antlr4ng";
+export class ClojureParser extends antlr.Parser {
+    static T__0 = 1;
+    static T__1 = 2;
+    static T__2 = 3;
+    static T__3 = 4;
+    static T__4 = 5;
+    static T__5 = 6;
+    static T__6 = 7;
+    static T__7 = 8;
+    static T__8 = 9;
+    static T__9 = 10;
+    static T__10 = 11;
+    static T__11 = 12;
+    static T__12 = 13;
+    static T__13 = 14;
+    static T__14 = 15;
+    static T__15 = 16;
+    static T__16 = 17;
+    static T__17 = 18;
+    static T__18 = 19;
+    static T__19 = 20;
+    static STRING = 21;
+    static FLOAT = 22;
+    static HEX = 23;
+    static BIN = 24;
+    static LONG = 25;
+    static BIGN = 26;
+    static CHAR_U = 27;
+    static CHAR_NAMED = 28;
+    static CHAR_ANY = 29;
+    static NIL = 30;
+    static BOOLEAN = 31;
+    static SYMBOL = 32;
+    static NS_SYMBOL = 33;
+    static PARAM_NAME = 34;
+    static TRASH = 35;
+    static RULE_file_ = 0;
+    static RULE_form = 1;
+    static RULE_forms = 2;
+    static RULE_list_ = 3;
+    static RULE_vector = 4;
+    static RULE_map_ = 5;
+    static RULE_set_ = 6;
+    static RULE_reader_macro = 7;
+    static RULE_quote = 8;
+    static RULE_backtick = 9;
+    static RULE_unquote = 10;
+    static RULE_unquote_splicing = 11;
+    static RULE_tag = 12;
+    static RULE_deref = 13;
+    static RULE_gensym = 14;
+    static RULE_lambda_ = 15;
+    static RULE_meta_data = 16;
+    static RULE_var_quote = 17;
+    static RULE_host_expr = 18;
+    static RULE_discard = 19;
+    static RULE_dispatch = 20;
+    static RULE_regex = 21;
+    static RULE_literal = 22;
+    static RULE_string_ = 23;
+    static RULE_hex_ = 24;
+    static RULE_bin_ = 25;
+    static RULE_bign = 26;
+    static RULE_number = 27;
+    static RULE_character = 28;
+    static RULE_named_char = 29;
+    static RULE_any_char = 30;
+    static RULE_u_hex_quad = 31;
+    static RULE_nil_ = 32;
+    static RULE_keyword = 33;
+    static RULE_simple_keyword = 34;
+    static RULE_macro_keyword = 35;
+    static RULE_symbol = 36;
+    static RULE_simple_sym = 37;
+    static RULE_ns_symbol = 38;
+    static RULE_param_name = 39;
+    static literalNames = [
+        null, "'('", "')'", "'['", "']'", "'{'", "'}'", "'#{'", "'''", "'`'",
+        "'~'", "'~@'", "'^'", "'@'", "'#'", "'#('", "'#^'", "'#''", "'#+'",
+        "'#_'", "':'", null, null, null, null, null, null, null, null, null,
+        "'nil'"
+    ];
+    static symbolicNames = [
+        null, null, null, null, null, null, null, null, null, null, null,
+        null, null, null, null, null, null, null, null, null, null, "STRING",
+        "FLOAT", "HEX", "BIN", "LONG", "BIGN", "CHAR_U", "CHAR_NAMED", "CHAR_ANY",
+        "NIL", "BOOLEAN", "SYMBOL", "NS_SYMBOL", "PARAM_NAME", "TRASH"
+    ];
+    static ruleNames = [
+        "file_", "form", "forms", "list_", "vector", "map_", "set_", "reader_macro",
+        "quote", "backtick", "unquote", "unquote_splicing", "tag", "deref",
+        "gensym", "lambda_", "meta_data", "var_quote", "host_expr", "discard",
+        "dispatch", "regex", "literal", "string_", "hex_", "bin_", "bign",
+        "number", "character", "named_char", "any_char", "u_hex_quad", "nil_",
+        "keyword", "simple_keyword", "macro_keyword", "symbol", "simple_sym",
+        "ns_symbol", "param_name",
+    ];
+    get grammarFileName() { return "Clojure.g4"; }
+    get literalNames() { return ClojureParser.literalNames; }
+    get symbolicNames() { return ClojureParser.symbolicNames; }
+    get ruleNames() { return ClojureParser.ruleNames; }
+    get serializedATN() { return ClojureParser._serializedATN; }
+    createFailedPredicateException(predicate, message) {
+        return new antlr.FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this.interpreter = new antlr.ParserATNSimulator(this, ClojureParser._ATN, ClojureParser.decisionsToDFA, new antlr.PredictionContextCache());
+    }
+    file_() {
+        let localContext = new File_Context(this.context, this.state);
+        this.enterRule(localContext, 0, ClojureParser.RULE_file_);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 83;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967210) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 7) !== 0)) {
+                    {
+                        {
+                            this.state = 80;
+                            this.form();
+                        }
+                    }
+                    this.state = 85;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 86;
+                this.match(ClojureParser.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;
+    }
+    form() {
+        let localContext = new FormContext(this.context, this.state);
+        this.enterRule(localContext, 2, ClojureParser.RULE_form);
+        try {
+            this.state = 93;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 1, this.context)) {
+                case 1:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 88;
+                        this.literal();
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 89;
+                        this.list_();
+                    }
+                    break;
+                case 3:
+                    this.enterOuterAlt(localContext, 3);
+                    {
+                        this.state = 90;
+                        this.vector();
+                    }
+                    break;
+                case 4:
+                    this.enterOuterAlt(localContext, 4);
+                    {
+                        this.state = 91;
+                        this.map_();
+                    }
+                    break;
+                case 5:
+                    this.enterOuterAlt(localContext, 5);
+                    {
+                        this.state = 92;
+                        this.reader_macro();
+                    }
+                    break;
+            }
+        }
+        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;
+    }
+    forms() {
+        let localContext = new FormsContext(this.context, this.state);
+        this.enterRule(localContext, 4, ClojureParser.RULE_forms);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 98;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967210) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 7) !== 0)) {
+                    {
+                        {
+                            this.state = 95;
+                            this.form();
+                        }
+                    }
+                    this.state = 100;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+            }
+        }
+        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;
+    }
+    list_() {
+        let localContext = new List_Context(this.context, this.state);
+        this.enterRule(localContext, 6, ClojureParser.RULE_list_);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 101;
+                this.match(ClojureParser.T__0);
+                this.state = 102;
+                this.forms();
+                this.state = 103;
+                this.match(ClojureParser.T__1);
+            }
+        }
+        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;
+    }
+    vector() {
+        let localContext = new VectorContext(this.context, this.state);
+        this.enterRule(localContext, 8, ClojureParser.RULE_vector);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 105;
+                this.match(ClojureParser.T__2);
+                this.state = 106;
+                this.forms();
+                this.state = 107;
+                this.match(ClojureParser.T__3);
+            }
+        }
+        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;
+    }
+    map_() {
+        let localContext = new Map_Context(this.context, this.state);
+        this.enterRule(localContext, 10, ClojureParser.RULE_map_);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 109;
+                this.match(ClojureParser.T__4);
+                this.state = 115;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967210) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 7) !== 0)) {
+                    {
+                        {
+                            this.state = 110;
+                            this.form();
+                            this.state = 111;
+                            this.form();
+                        }
+                    }
+                    this.state = 117;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 118;
+                this.match(ClojureParser.T__5);
+            }
+        }
+        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;
+    }
+    set_() {
+        let localContext = new Set_Context(this.context, this.state);
+        this.enterRule(localContext, 12, ClojureParser.RULE_set_);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 120;
+                this.match(ClojureParser.T__6);
+                this.state = 121;
+                this.forms();
+                this.state = 122;
+                this.match(ClojureParser.T__5);
+            }
+        }
+        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;
+    }
+    reader_macro() {
+        let localContext = new Reader_macroContext(this.context, this.state);
+        this.enterRule(localContext, 14, ClojureParser.RULE_reader_macro);
+        try {
+            this.state = 139;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context)) {
+                case 1:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 124;
+                        this.lambda_();
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 125;
+                        this.meta_data();
+                    }
+                    break;
+                case 3:
+                    this.enterOuterAlt(localContext, 3);
+                    {
+                        this.state = 126;
+                        this.regex();
+                    }
+                    break;
+                case 4:
+                    this.enterOuterAlt(localContext, 4);
+                    {
+                        this.state = 127;
+                        this.var_quote();
+                    }
+                    break;
+                case 5:
+                    this.enterOuterAlt(localContext, 5);
+                    {
+                        this.state = 128;
+                        this.host_expr();
+                    }
+                    break;
+                case 6:
+                    this.enterOuterAlt(localContext, 6);
+                    {
+                        this.state = 129;
+                        this.set_();
+                    }
+                    break;
+                case 7:
+                    this.enterOuterAlt(localContext, 7);
+                    {
+                        this.state = 130;
+                        this.tag();
+                    }
+                    break;
+                case 8:
+                    this.enterOuterAlt(localContext, 8);
+                    {
+                        this.state = 131;
+                        this.discard();
+                    }
+                    break;
+                case 9:
+                    this.enterOuterAlt(localContext, 9);
+                    {
+                        this.state = 132;
+                        this.dispatch();
+                    }
+                    break;
+                case 10:
+                    this.enterOuterAlt(localContext, 10);
+                    {
+                        this.state = 133;
+                        this.deref();
+                    }
+                    break;
+                case 11:
+                    this.enterOuterAlt(localContext, 11);
+                    {
+                        this.state = 134;
+                        this.quote();
+                    }
+                    break;
+                case 12:
+                    this.enterOuterAlt(localContext, 12);
+                    {
+                        this.state = 135;
+                        this.backtick();
+                    }
+                    break;
+                case 13:
+                    this.enterOuterAlt(localContext, 13);
+                    {
+                        this.state = 136;
+                        this.unquote();
+                    }
+                    break;
+                case 14:
+                    this.enterOuterAlt(localContext, 14);
+                    {
+                        this.state = 137;
+                        this.unquote_splicing();
+                    }
+                    break;
+                case 15:
+                    this.enterOuterAlt(localContext, 15);
+                    {
+                        this.state = 138;
+                        this.gensym();
+                    }
+                    break;
+            }
+        }
+        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;
+    }
+    quote() {
+        let localContext = new QuoteContext(this.context, this.state);
+        this.enterRule(localContext, 16, ClojureParser.RULE_quote);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 141;
+                this.match(ClojureParser.T__7);
+                this.state = 142;
+                this.form();
+            }
+        }
+        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;
+    }
+    backtick() {
+        let localContext = new BacktickContext(this.context, this.state);
+        this.enterRule(localContext, 18, ClojureParser.RULE_backtick);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 144;
+                this.match(ClojureParser.T__8);
+                this.state = 145;
+                this.form();
+            }
+        }
+        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;
+    }
+    unquote() {
+        let localContext = new UnquoteContext(this.context, this.state);
+        this.enterRule(localContext, 20, ClojureParser.RULE_unquote);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 147;
+                this.match(ClojureParser.T__9);
+                this.state = 148;
+                this.form();
+            }
+        }
+        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;
+    }
+    unquote_splicing() {
+        let localContext = new Unquote_splicingContext(this.context, this.state);
+        this.enterRule(localContext, 22, ClojureParser.RULE_unquote_splicing);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 150;
+                this.match(ClojureParser.T__10);
+                this.state = 151;
+                this.form();
+            }
+        }
+        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;
+    }
+    tag() {
+        let localContext = new TagContext(this.context, this.state);
+        this.enterRule(localContext, 24, ClojureParser.RULE_tag);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 153;
+                this.match(ClojureParser.T__11);
+                this.state = 154;
+                this.form();
+                this.state = 155;
+                this.form();
+            }
+        }
+        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;
+    }
+    deref() {
+        let localContext = new DerefContext(this.context, this.state);
+        this.enterRule(localContext, 26, ClojureParser.RULE_deref);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 157;
+                this.match(ClojureParser.T__12);
+                this.state = 158;
+                this.form();
+            }
+        }
+        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;
+    }
+    gensym() {
+        let localContext = new GensymContext(this.context, this.state);
+        this.enterRule(localContext, 28, ClojureParser.RULE_gensym);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 160;
+                this.match(ClojureParser.SYMBOL);
+                this.state = 161;
+                this.match(ClojureParser.T__13);
+            }
+        }
+        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;
+    }
+    lambda_() {
+        let localContext = new Lambda_Context(this.context, this.state);
+        this.enterRule(localContext, 30, ClojureParser.RULE_lambda_);
+        let _la;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 163;
+                this.match(ClojureParser.T__14);
+                this.state = 167;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967210) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 7) !== 0)) {
+                    {
+                        {
+                            this.state = 164;
+                            this.form();
+                        }
+                    }
+                    this.state = 169;
+                    this.errorHandler.sync(this);
+                    _la = this.tokenStream.LA(1);
+                }
+                this.state = 170;
+                this.match(ClojureParser.T__1);
+            }
+        }
+        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;
+    }
+    meta_data() {
+        let localContext = new Meta_dataContext(this.context, this.state);
+        this.enterRule(localContext, 32, ClojureParser.RULE_meta_data);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 172;
+                this.match(ClojureParser.T__15);
+                this.state = 177;
+                this.errorHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this.tokenStream, 6, this.context)) {
+                    case 1:
+                        {
+                            this.state = 173;
+                            this.map_();
+                            this.state = 174;
+                            this.form();
+                        }
+                        break;
+                    case 2:
+                        {
+                            this.state = 176;
+                            this.form();
+                        }
+                        break;
+                }
+            }
+        }
+        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;
+    }
+    var_quote() {
+        let localContext = new Var_quoteContext(this.context, this.state);
+        this.enterRule(localContext, 34, ClojureParser.RULE_var_quote);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 179;
+                this.match(ClojureParser.T__16);
+                this.state = 180;
+                this.symbol_();
+            }
+        }
+        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;
+    }
+    host_expr() {
+        let localContext = new Host_exprContext(this.context, this.state);
+        this.enterRule(localContext, 36, ClojureParser.RULE_host_expr);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 182;
+                this.match(ClojureParser.T__17);
+                this.state = 183;
+                this.form();
+                this.state = 184;
+                this.form();
+            }
+        }
+        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;
+    }
+    discard() {
+        let localContext = new DiscardContext(this.context, this.state);
+        this.enterRule(localContext, 38, ClojureParser.RULE_discard);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 186;
+                this.match(ClojureParser.T__18);
+                this.state = 187;
+                this.form();
+            }
+        }
+        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;
+    }
+    dispatch() {
+        let localContext = new DispatchContext(this.context, this.state);
+        this.enterRule(localContext, 40, ClojureParser.RULE_dispatch);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 189;
+                this.match(ClojureParser.T__13);
+                this.state = 190;
+                this.symbol_();
+                this.state = 191;
+                this.form();
+            }
+        }
+        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;
+    }
+    regex() {
+        let localContext = new RegexContext(this.context, this.state);
+        this.enterRule(localContext, 42, ClojureParser.RULE_regex);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 193;
+                this.match(ClojureParser.T__13);
+                this.state = 194;
+                this.string_();
+            }
+        }
+        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;
+    }
+    literal() {
+        let localContext = new LiteralContext(this.context, this.state);
+        this.enterRule(localContext, 44, ClojureParser.RULE_literal);
+        try {
+            this.state = 204;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+                case ClojureParser.STRING:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 196;
+                        this.string_();
+                    }
+                    break;
+                case ClojureParser.FLOAT:
+                case ClojureParser.HEX:
+                case ClojureParser.BIN:
+                case ClojureParser.LONG:
+                case ClojureParser.BIGN:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 197;
+                        this.number_();
+                    }
+                    break;
+                case ClojureParser.CHAR_U:
+                case ClojureParser.CHAR_NAMED:
+                case ClojureParser.CHAR_ANY:
+                    this.enterOuterAlt(localContext, 3);
+                    {
+                        this.state = 198;
+                        this.character();
+                    }
+                    break;
+                case ClojureParser.NIL:
+                    this.enterOuterAlt(localContext, 4);
+                    {
+                        this.state = 199;
+                        this.nil_();
+                    }
+                    break;
+                case ClojureParser.BOOLEAN:
+                    this.enterOuterAlt(localContext, 5);
+                    {
+                        this.state = 200;
+                        this.match(ClojureParser.BOOLEAN);
+                    }
+                    break;
+                case ClojureParser.T__19:
+                    this.enterOuterAlt(localContext, 6);
+                    {
+                        this.state = 201;
+                        this.keyword();
+                    }
+                    break;
+                case ClojureParser.SYMBOL:
+                case ClojureParser.NS_SYMBOL:
+                    this.enterOuterAlt(localContext, 7);
+                    {
+                        this.state = 202;
+                        this.symbol_();
+                    }
+                    break;
+                case ClojureParser.PARAM_NAME:
+                    this.enterOuterAlt(localContext, 8);
+                    {
+                        this.state = 203;
+                        this.param_name();
+                    }
+                    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;
+    }
+    string_() {
+        let localContext = new String_Context(this.context, this.state);
+        this.enterRule(localContext, 46, ClojureParser.RULE_string_);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 206;
+                this.match(ClojureParser.STRING);
+            }
+        }
+        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;
+    }
+    hex_() {
+        let localContext = new Hex_Context(this.context, this.state);
+        this.enterRule(localContext, 48, ClojureParser.RULE_hex_);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 208;
+                this.match(ClojureParser.HEX);
+            }
+        }
+        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;
+    }
+    bin_() {
+        let localContext = new Bin_Context(this.context, this.state);
+        this.enterRule(localContext, 50, ClojureParser.RULE_bin_);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 210;
+                this.match(ClojureParser.BIN);
+            }
+        }
+        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;
+    }
+    bign() {
+        let localContext = new BignContext(this.context, this.state);
+        this.enterRule(localContext, 52, ClojureParser.RULE_bign);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 212;
+                this.match(ClojureParser.BIGN);
+            }
+        }
+        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;
+    }
+    number_() {
+        let localContext = new NumberContext(this.context, this.state);
+        this.enterRule(localContext, 54, ClojureParser.RULE_number);
+        try {
+            this.state = 219;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+                case ClojureParser.FLOAT:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 214;
+                        this.match(ClojureParser.FLOAT);
+                    }
+                    break;
+                case ClojureParser.HEX:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 215;
+                        this.hex_();
+                    }
+                    break;
+                case ClojureParser.BIN:
+                    this.enterOuterAlt(localContext, 3);
+                    {
+                        this.state = 216;
+                        this.bin_();
+                    }
+                    break;
+                case ClojureParser.BIGN:
+                    this.enterOuterAlt(localContext, 4);
+                    {
+                        this.state = 217;
+                        this.bign();
+                    }
+                    break;
+                case ClojureParser.LONG:
+                    this.enterOuterAlt(localContext, 5);
+                    {
+                        this.state = 218;
+                        this.match(ClojureParser.LONG);
+                    }
+                    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;
+    }
+    character() {
+        let localContext = new CharacterContext(this.context, this.state);
+        this.enterRule(localContext, 56, ClojureParser.RULE_character);
+        try {
+            this.state = 224;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+                case ClojureParser.CHAR_NAMED:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 221;
+                        this.named_char();
+                    }
+                    break;
+                case ClojureParser.CHAR_U:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 222;
+                        this.u_hex_quad();
+                    }
+                    break;
+                case ClojureParser.CHAR_ANY:
+                    this.enterOuterAlt(localContext, 3);
+                    {
+                        this.state = 223;
+                        this.any_char();
+                    }
+                    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;
+    }
+    named_char() {
+        let localContext = new Named_charContext(this.context, this.state);
+        this.enterRule(localContext, 58, ClojureParser.RULE_named_char);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 226;
+                this.match(ClojureParser.CHAR_NAMED);
+            }
+        }
+        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;
+    }
+    any_char() {
+        let localContext = new Any_charContext(this.context, this.state);
+        this.enterRule(localContext, 60, ClojureParser.RULE_any_char);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 228;
+                this.match(ClojureParser.CHAR_ANY);
+            }
+        }
+        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;
+    }
+    u_hex_quad() {
+        let localContext = new U_hex_quadContext(this.context, this.state);
+        this.enterRule(localContext, 62, ClojureParser.RULE_u_hex_quad);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 230;
+                this.match(ClojureParser.CHAR_U);
+            }
+        }
+        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;
+    }
+    nil_() {
+        let localContext = new Nil_Context(this.context, this.state);
+        this.enterRule(localContext, 64, ClojureParser.RULE_nil_);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 232;
+                this.match(ClojureParser.NIL);
+            }
+        }
+        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;
+    }
+    keyword() {
+        let localContext = new KeywordContext(this.context, this.state);
+        this.enterRule(localContext, 66, ClojureParser.RULE_keyword);
+        try {
+            this.state = 236;
+            this.errorHandler.sync(this);
+            switch (this.interpreter.adaptivePredict(this.tokenStream, 10, this.context)) {
+                case 1:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 234;
+                        this.macro_keyword();
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 235;
+                        this.simple_keyword();
+                    }
+                    break;
+            }
+        }
+        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;
+    }
+    simple_keyword() {
+        let localContext = new Simple_keywordContext(this.context, this.state);
+        this.enterRule(localContext, 68, ClojureParser.RULE_simple_keyword);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 238;
+                this.match(ClojureParser.T__19);
+                this.state = 239;
+                this.symbol_();
+            }
+        }
+        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;
+    }
+    macro_keyword() {
+        let localContext = new Macro_keywordContext(this.context, this.state);
+        this.enterRule(localContext, 70, ClojureParser.RULE_macro_keyword);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 241;
+                this.match(ClojureParser.T__19);
+                this.state = 242;
+                this.match(ClojureParser.T__19);
+                this.state = 243;
+                this.symbol_();
+            }
+        }
+        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;
+    }
+    symbol_() {
+        let localContext = new SymbolContext(this.context, this.state);
+        this.enterRule(localContext, 72, ClojureParser.RULE_symbol);
+        try {
+            this.state = 247;
+            this.errorHandler.sync(this);
+            switch (this.tokenStream.LA(1)) {
+                case ClojureParser.NS_SYMBOL:
+                    this.enterOuterAlt(localContext, 1);
+                    {
+                        this.state = 245;
+                        this.ns_symbol();
+                    }
+                    break;
+                case ClojureParser.SYMBOL:
+                    this.enterOuterAlt(localContext, 2);
+                    {
+                        this.state = 246;
+                        this.simple_sym();
+                    }
+                    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;
+    }
+    simple_sym() {
+        let localContext = new Simple_symContext(this.context, this.state);
+        this.enterRule(localContext, 74, ClojureParser.RULE_simple_sym);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 249;
+                this.match(ClojureParser.SYMBOL);
+            }
+        }
+        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;
+    }
+    ns_symbol() {
+        let localContext = new Ns_symbolContext(this.context, this.state);
+        this.enterRule(localContext, 76, ClojureParser.RULE_ns_symbol);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 251;
+                this.match(ClojureParser.NS_SYMBOL);
+            }
+        }
+        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;
+    }
+    param_name() {
+        let localContext = new Param_nameContext(this.context, this.state);
+        this.enterRule(localContext, 78, ClojureParser.RULE_param_name);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+                this.state = 253;
+                this.match(ClojureParser.PARAM_NAME);
+            }
+        }
+        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, 35, 256, 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, 2, 20,
+        7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26,
+        2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33,
+        7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39,
+        1, 0, 5, 0, 82, 8, 0, 10, 0, 12, 0, 85, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1,
+        94, 8, 1, 1, 2, 5, 2, 97, 8, 2, 10, 2, 12, 2, 100, 9, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4,
+        1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 5, 5, 114, 8, 5, 10, 5, 12, 5, 117, 9, 5, 1, 5, 1, 5, 1,
+        6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1,
+        7, 1, 7, 1, 7, 3, 7, 140, 8, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11,
+        1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 15,
+        1, 15, 5, 15, 166, 8, 15, 10, 15, 12, 15, 169, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16,
+        1, 16, 1, 16, 3, 16, 178, 8, 16, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19,
+        1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22,
+        1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 205, 8, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25,
+        1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 220, 8, 27, 1, 28, 1, 28, 1, 28,
+        3, 28, 225, 8, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 32, 1, 32, 1, 33, 1, 33,
+        3, 33, 237, 8, 33, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 3, 36,
+        248, 8, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 0, 0, 40, 0, 2, 4, 6, 8, 10,
+        12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54,
+        56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 0, 0, 253, 0, 83, 1, 0, 0, 0, 2, 93, 1,
+        0, 0, 0, 4, 98, 1, 0, 0, 0, 6, 101, 1, 0, 0, 0, 8, 105, 1, 0, 0, 0, 10, 109, 1, 0, 0, 0, 12,
+        120, 1, 0, 0, 0, 14, 139, 1, 0, 0, 0, 16, 141, 1, 0, 0, 0, 18, 144, 1, 0, 0, 0, 20, 147,
+        1, 0, 0, 0, 22, 150, 1, 0, 0, 0, 24, 153, 1, 0, 0, 0, 26, 157, 1, 0, 0, 0, 28, 160, 1, 0,
+        0, 0, 30, 163, 1, 0, 0, 0, 32, 172, 1, 0, 0, 0, 34, 179, 1, 0, 0, 0, 36, 182, 1, 0, 0, 0,
+        38, 186, 1, 0, 0, 0, 40, 189, 1, 0, 0, 0, 42, 193, 1, 0, 0, 0, 44, 204, 1, 0, 0, 0, 46, 206,
+        1, 0, 0, 0, 48, 208, 1, 0, 0, 0, 50, 210, 1, 0, 0, 0, 52, 212, 1, 0, 0, 0, 54, 219, 1, 0,
+        0, 0, 56, 224, 1, 0, 0, 0, 58, 226, 1, 0, 0, 0, 60, 228, 1, 0, 0, 0, 62, 230, 1, 0, 0, 0,
+        64, 232, 1, 0, 0, 0, 66, 236, 1, 0, 0, 0, 68, 238, 1, 0, 0, 0, 70, 241, 1, 0, 0, 0, 72, 247,
+        1, 0, 0, 0, 74, 249, 1, 0, 0, 0, 76, 251, 1, 0, 0, 0, 78, 253, 1, 0, 0, 0, 80, 82, 3, 2, 1,
+        0, 81, 80, 1, 0, 0, 0, 82, 85, 1, 0, 0, 0, 83, 81, 1, 0, 0, 0, 83, 84, 1, 0, 0, 0, 84, 86,
+        1, 0, 0, 0, 85, 83, 1, 0, 0, 0, 86, 87, 5, 0, 0, 1, 87, 1, 1, 0, 0, 0, 88, 94, 3, 44, 22, 0,
+        89, 94, 3, 6, 3, 0, 90, 94, 3, 8, 4, 0, 91, 94, 3, 10, 5, 0, 92, 94, 3, 14, 7, 0, 93, 88,
+        1, 0, 0, 0, 93, 89, 1, 0, 0, 0, 93, 90, 1, 0, 0, 0, 93, 91, 1, 0, 0, 0, 93, 92, 1, 0, 0, 0,
+        94, 3, 1, 0, 0, 0, 95, 97, 3, 2, 1, 0, 96, 95, 1, 0, 0, 0, 97, 100, 1, 0, 0, 0, 98, 96, 1,
+        0, 0, 0, 98, 99, 1, 0, 0, 0, 99, 5, 1, 0, 0, 0, 100, 98, 1, 0, 0, 0, 101, 102, 5, 1, 0, 0,
+        102, 103, 3, 4, 2, 0, 103, 104, 5, 2, 0, 0, 104, 7, 1, 0, 0, 0, 105, 106, 5, 3, 0, 0, 106,
+        107, 3, 4, 2, 0, 107, 108, 5, 4, 0, 0, 108, 9, 1, 0, 0, 0, 109, 115, 5, 5, 0, 0, 110, 111,
+        3, 2, 1, 0, 111, 112, 3, 2, 1, 0, 112, 114, 1, 0, 0, 0, 113, 110, 1, 0, 0, 0, 114, 117,
+        1, 0, 0, 0, 115, 113, 1, 0, 0, 0, 115, 116, 1, 0, 0, 0, 116, 118, 1, 0, 0, 0, 117, 115,
+        1, 0, 0, 0, 118, 119, 5, 6, 0, 0, 119, 11, 1, 0, 0, 0, 120, 121, 5, 7, 0, 0, 121, 122, 3,
+        4, 2, 0, 122, 123, 5, 6, 0, 0, 123, 13, 1, 0, 0, 0, 124, 140, 3, 30, 15, 0, 125, 140, 3,
+        32, 16, 0, 126, 140, 3, 42, 21, 0, 127, 140, 3, 34, 17, 0, 128, 140, 3, 36, 18, 0, 129,
+        140, 3, 12, 6, 0, 130, 140, 3, 24, 12, 0, 131, 140, 3, 38, 19, 0, 132, 140, 3, 40, 20,
+        0, 133, 140, 3, 26, 13, 0, 134, 140, 3, 16, 8, 0, 135, 140, 3, 18, 9, 0, 136, 140, 3,
+        20, 10, 0, 137, 140, 3, 22, 11, 0, 138, 140, 3, 28, 14, 0, 139, 124, 1, 0, 0, 0, 139,
+        125, 1, 0, 0, 0, 139, 126, 1, 0, 0, 0, 139, 127, 1, 0, 0, 0, 139, 128, 1, 0, 0, 0, 139,
+        129, 1, 0, 0, 0, 139, 130, 1, 0, 0, 0, 139, 131, 1, 0, 0, 0, 139, 132, 1, 0, 0, 0, 139,
+        133, 1, 0, 0, 0, 139, 134, 1, 0, 0, 0, 139, 135, 1, 0, 0, 0, 139, 136, 1, 0, 0, 0, 139,
+        137, 1, 0, 0, 0, 139, 138, 1, 0, 0, 0, 140, 15, 1, 0, 0, 0, 141, 142, 5, 8, 0, 0, 142, 143,
+        3, 2, 1, 0, 143, 17, 1, 0, 0, 0, 144, 145, 5, 9, 0, 0, 145, 146, 3, 2, 1, 0, 146, 19, 1,
+        0, 0, 0, 147, 148, 5, 10, 0, 0, 148, 149, 3, 2, 1, 0, 149, 21, 1, 0, 0, 0, 150, 151, 5,
+        11, 0, 0, 151, 152, 3, 2, 1, 0, 152, 23, 1, 0, 0, 0, 153, 154, 5, 12, 0, 0, 154, 155, 3,
+        2, 1, 0, 155, 156, 3, 2, 1, 0, 156, 25, 1, 0, 0, 0, 157, 158, 5, 13, 0, 0, 158, 159, 3,
+        2, 1, 0, 159, 27, 1, 0, 0, 0, 160, 161, 5, 32, 0, 0, 161, 162, 5, 14, 0, 0, 162, 29, 1,
+        0, 0, 0, 163, 167, 5, 15, 0, 0, 164, 166, 3, 2, 1, 0, 165, 164, 1, 0, 0, 0, 166, 169, 1,
+        0, 0, 0, 167, 165, 1, 0, 0, 0, 167, 168, 1, 0, 0, 0, 168, 170, 1, 0, 0, 0, 169, 167, 1,
+        0, 0, 0, 170, 171, 5, 2, 0, 0, 171, 31, 1, 0, 0, 0, 172, 177, 5, 16, 0, 0, 173, 174, 3,
+        10, 5, 0, 174, 175, 3, 2, 1, 0, 175, 178, 1, 0, 0, 0, 176, 178, 3, 2, 1, 0, 177, 173, 1,
+        0, 0, 0, 177, 176, 1, 0, 0, 0, 178, 33, 1, 0, 0, 0, 179, 180, 5, 17, 0, 0, 180, 181, 3,
+        72, 36, 0, 181, 35, 1, 0, 0, 0, 182, 183, 5, 18, 0, 0, 183, 184, 3, 2, 1, 0, 184, 185,
+        3, 2, 1, 0, 185, 37, 1, 0, 0, 0, 186, 187, 5, 19, 0, 0, 187, 188, 3, 2, 1, 0, 188, 39, 1,
+        0, 0, 0, 189, 190, 5, 14, 0, 0, 190, 191, 3, 72, 36, 0, 191, 192, 3, 2, 1, 0, 192, 41,
+        1, 0, 0, 0, 193, 194, 5, 14, 0, 0, 194, 195, 3, 46, 23, 0, 195, 43, 1, 0, 0, 0, 196, 205,
+        3, 46, 23, 0, 197, 205, 3, 54, 27, 0, 198, 205, 3, 56, 28, 0, 199, 205, 3, 64, 32, 0,
+        200, 205, 5, 31, 0, 0, 201, 205, 3, 66, 33, 0, 202, 205, 3, 72, 36, 0, 203, 205, 3, 78,
+        39, 0, 204, 196, 1, 0, 0, 0, 204, 197, 1, 0, 0, 0, 204, 198, 1, 0, 0, 0, 204, 199, 1, 0,
+        0, 0, 204, 200, 1, 0, 0, 0, 204, 201, 1, 0, 0, 0, 204, 202, 1, 0, 0, 0, 204, 203, 1, 0,
+        0, 0, 205, 45, 1, 0, 0, 0, 206, 207, 5, 21, 0, 0, 207, 47, 1, 0, 0, 0, 208, 209, 5, 23,
+        0, 0, 209, 49, 1, 0, 0, 0, 210, 211, 5, 24, 0, 0, 211, 51, 1, 0, 0, 0, 212, 213, 5, 26,
+        0, 0, 213, 53, 1, 0, 0, 0, 214, 220, 5, 22, 0, 0, 215, 220, 3, 48, 24, 0, 216, 220, 3,
+        50, 25, 0, 217, 220, 3, 52, 26, 0, 218, 220, 5, 25, 0, 0, 219, 214, 1, 0, 0, 0, 219, 215,
+        1, 0, 0, 0, 219, 216, 1, 0, 0, 0, 219, 217, 1, 0, 0, 0, 219, 218, 1, 0, 0, 0, 220, 55, 1,
+        0, 0, 0, 221, 225, 3, 58, 29, 0, 222, 225, 3, 62, 31, 0, 223, 225, 3, 60, 30, 0, 224,
+        221, 1, 0, 0, 0, 224, 222, 1, 0, 0, 0, 224, 223, 1, 0, 0, 0, 225, 57, 1, 0, 0, 0, 226, 227,
+        5, 28, 0, 0, 227, 59, 1, 0, 0, 0, 228, 229, 5, 29, 0, 0, 229, 61, 1, 0, 0, 0, 230, 231,
+        5, 27, 0, 0, 231, 63, 1, 0, 0, 0, 232, 233, 5, 30, 0, 0, 233, 65, 1, 0, 0, 0, 234, 237,
+        3, 70, 35, 0, 235, 237, 3, 68, 34, 0, 236, 234, 1, 0, 0, 0, 236, 235, 1, 0, 0, 0, 237,
+        67, 1, 0, 0, 0, 238, 239, 5, 20, 0, 0, 239, 240, 3, 72, 36, 0, 240, 69, 1, 0, 0, 0, 241,
+        242, 5, 20, 0, 0, 242, 243, 5, 20, 0, 0, 243, 244, 3, 72, 36, 0, 244, 71, 1, 0, 0, 0, 245,
+        248, 3, 76, 38, 0, 246, 248, 3, 74, 37, 0, 247, 245, 1, 0, 0, 0, 247, 246, 1, 0, 0, 0,
+        248, 73, 1, 0, 0, 0, 249, 250, 5, 32, 0, 0, 250, 75, 1, 0, 0, 0, 251, 252, 5, 33, 0, 0,
+        252, 77, 1, 0, 0, 0, 253, 254, 5, 34, 0, 0, 254, 79, 1, 0, 0, 0, 12, 83, 93, 98, 115, 139,
+        167, 177, 204, 219, 224, 236, 247
+    ];
+    static __ATN;
+    static get _ATN() {
+        if (!ClojureParser.__ATN) {
+            ClojureParser.__ATN = new antlr.ATNDeserializer().deserialize(ClojureParser._serializedATN);
+        }
+        return ClojureParser.__ATN;
+    }
+    static vocabulary = new antlr.Vocabulary(ClojureParser.literalNames, ClojureParser.symbolicNames, []);
+    get vocabulary() {
+        return ClojureParser.vocabulary;
+    }
+    static decisionsToDFA = ClojureParser._ATN.decisionToState.map((ds, index) => new antlr.DFA(ds, index));
+}
+export class File_Context extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    EOF() {
+        return this.getToken(ClojureParser.EOF, 0);
+    }
+    form(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(FormContext);
+        }
+        return this.getRuleContext(i, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_file_;
+    }
+    accept(visitor) {
+        if (visitor.visitFile_) {
+            return visitor.visitFile_(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class FormContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    literal() {
+        return this.getRuleContext(0, LiteralContext);
+    }
+    list_() {
+        return this.getRuleContext(0, List_Context);
+    }
+    vector() {
+        return this.getRuleContext(0, VectorContext);
+    }
+    map_() {
+        return this.getRuleContext(0, Map_Context);
+    }
+    reader_macro() {
+        return this.getRuleContext(0, Reader_macroContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_form;
+    }
+    accept(visitor) {
+        if (visitor.visitForm) {
+            return visitor.visitForm(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class FormsContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(FormContext);
+        }
+        return this.getRuleContext(i, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_forms;
+    }
+    accept(visitor) {
+        if (visitor.visitForms) {
+            return visitor.visitForms(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class List_Context extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    forms() {
+        return this.getRuleContext(0, FormsContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_list_;
+    }
+    accept(visitor) {
+        if (visitor.visitList_) {
+            return visitor.visitList_(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class VectorContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    forms() {
+        return this.getRuleContext(0, FormsContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_vector;
+    }
+    accept(visitor) {
+        if (visitor.visitVector) {
+            return visitor.visitVector(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Map_Context extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(FormContext);
+        }
+        return this.getRuleContext(i, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_map_;
+    }
+    accept(visitor) {
+        if (visitor.visitMap_) {
+            return visitor.visitMap_(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Set_Context extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    forms() {
+        return this.getRuleContext(0, FormsContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_set_;
+    }
+    accept(visitor) {
+        if (visitor.visitSet_) {
+            return visitor.visitSet_(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Reader_macroContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    lambda_() {
+        return this.getRuleContext(0, Lambda_Context);
+    }
+    meta_data() {
+        return this.getRuleContext(0, Meta_dataContext);
+    }
+    regex() {
+        return this.getRuleContext(0, RegexContext);
+    }
+    var_quote() {
+        return this.getRuleContext(0, Var_quoteContext);
+    }
+    host_expr() {
+        return this.getRuleContext(0, Host_exprContext);
+    }
+    set_() {
+        return this.getRuleContext(0, Set_Context);
+    }
+    tag() {
+        return this.getRuleContext(0, TagContext);
+    }
+    discard() {
+        return this.getRuleContext(0, DiscardContext);
+    }
+    dispatch() {
+        return this.getRuleContext(0, DispatchContext);
+    }
+    deref() {
+        return this.getRuleContext(0, DerefContext);
+    }
+    quote() {
+        return this.getRuleContext(0, QuoteContext);
+    }
+    backtick() {
+        return this.getRuleContext(0, BacktickContext);
+    }
+    unquote() {
+        return this.getRuleContext(0, UnquoteContext);
+    }
+    unquote_splicing() {
+        return this.getRuleContext(0, Unquote_splicingContext);
+    }
+    gensym() {
+        return this.getRuleContext(0, GensymContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_reader_macro;
+    }
+    accept(visitor) {
+        if (visitor.visitReader_macro) {
+            return visitor.visitReader_macro(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class QuoteContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form() {
+        return this.getRuleContext(0, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_quote;
+    }
+    accept(visitor) {
+        if (visitor.visitQuote) {
+            return visitor.visitQuote(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class BacktickContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form() {
+        return this.getRuleContext(0, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_backtick;
+    }
+    accept(visitor) {
+        if (visitor.visitBacktick) {
+            return visitor.visitBacktick(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class UnquoteContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form() {
+        return this.getRuleContext(0, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_unquote;
+    }
+    accept(visitor) {
+        if (visitor.visitUnquote) {
+            return visitor.visitUnquote(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Unquote_splicingContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form() {
+        return this.getRuleContext(0, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_unquote_splicing;
+    }
+    accept(visitor) {
+        if (visitor.visitUnquote_splicing) {
+            return visitor.visitUnquote_splicing(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class TagContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(FormContext);
+        }
+        return this.getRuleContext(i, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_tag;
+    }
+    accept(visitor) {
+        if (visitor.visitTag) {
+            return visitor.visitTag(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class DerefContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form() {
+        return this.getRuleContext(0, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_deref;
+    }
+    accept(visitor) {
+        if (visitor.visitDeref) {
+            return visitor.visitDeref(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class GensymContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    SYMBOL() {
+        return this.getToken(ClojureParser.SYMBOL, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_gensym;
+    }
+    accept(visitor) {
+        if (visitor.visitGensym) {
+            return visitor.visitGensym(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Lambda_Context extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(FormContext);
+        }
+        return this.getRuleContext(i, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_lambda_;
+    }
+    accept(visitor) {
+        if (visitor.visitLambda_) {
+            return visitor.visitLambda_(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Meta_dataContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    map_() {
+        return this.getRuleContext(0, Map_Context);
+    }
+    form() {
+        return this.getRuleContext(0, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_meta_data;
+    }
+    accept(visitor) {
+        if (visitor.visitMeta_data) {
+            return visitor.visitMeta_data(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Var_quoteContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    symbol() {
+        return this.getRuleContext(0, SymbolContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_var_quote;
+    }
+    accept(visitor) {
+        if (visitor.visitVar_quote) {
+            return visitor.visitVar_quote(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Host_exprContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(FormContext);
+        }
+        return this.getRuleContext(i, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_host_expr;
+    }
+    accept(visitor) {
+        if (visitor.visitHost_expr) {
+            return visitor.visitHost_expr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class DiscardContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    form() {
+        return this.getRuleContext(0, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_discard;
+    }
+    accept(visitor) {
+        if (visitor.visitDiscard) {
+            return visitor.visitDiscard(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class DispatchContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    symbol() {
+        return this.getRuleContext(0, SymbolContext);
+    }
+    form() {
+        return this.getRuleContext(0, FormContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_dispatch;
+    }
+    accept(visitor) {
+        if (visitor.visitDispatch) {
+            return visitor.visitDispatch(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class RegexContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    string_() {
+        return this.getRuleContext(0, String_Context);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_regex;
+    }
+    accept(visitor) {
+        if (visitor.visitRegex) {
+            return visitor.visitRegex(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class LiteralContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    string_() {
+        return this.getRuleContext(0, String_Context);
+    }
+    number() {
+        return this.getRuleContext(0, NumberContext);
+    }
+    character() {
+        return this.getRuleContext(0, CharacterContext);
+    }
+    nil_() {
+        return this.getRuleContext(0, Nil_Context);
+    }
+    BOOLEAN() {
+        return this.getToken(ClojureParser.BOOLEAN, 0);
+    }
+    keyword() {
+        return this.getRuleContext(0, KeywordContext);
+    }
+    symbol() {
+        return this.getRuleContext(0, SymbolContext);
+    }
+    param_name() {
+        return this.getRuleContext(0, Param_nameContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_literal;
+    }
+    accept(visitor) {
+        if (visitor.visitLiteral) {
+            return visitor.visitLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class String_Context extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    STRING() {
+        return this.getToken(ClojureParser.STRING, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_string_;
+    }
+    accept(visitor) {
+        if (visitor.visitString_) {
+            return visitor.visitString_(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Hex_Context extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    HEX() {
+        return this.getToken(ClojureParser.HEX, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_hex_;
+    }
+    accept(visitor) {
+        if (visitor.visitHex_) {
+            return visitor.visitHex_(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Bin_Context extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    BIN() {
+        return this.getToken(ClojureParser.BIN, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_bin_;
+    }
+    accept(visitor) {
+        if (visitor.visitBin_) {
+            return visitor.visitBin_(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class BignContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    BIGN() {
+        return this.getToken(ClojureParser.BIGN, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_bign;
+    }
+    accept(visitor) {
+        if (visitor.visitBign) {
+            return visitor.visitBign(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class NumberContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    FLOAT() {
+        return this.getToken(ClojureParser.FLOAT, 0);
+    }
+    hex_() {
+        return this.getRuleContext(0, Hex_Context);
+    }
+    bin_() {
+        return this.getRuleContext(0, Bin_Context);
+    }
+    bign() {
+        return this.getRuleContext(0, BignContext);
+    }
+    LONG() {
+        return this.getToken(ClojureParser.LONG, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_number;
+    }
+    accept(visitor) {
+        if (visitor.visitNumber) {
+            return visitor.visitNumber(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class CharacterContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    named_char() {
+        return this.getRuleContext(0, Named_charContext);
+    }
+    u_hex_quad() {
+        return this.getRuleContext(0, U_hex_quadContext);
+    }
+    any_char() {
+        return this.getRuleContext(0, Any_charContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_character;
+    }
+    accept(visitor) {
+        if (visitor.visitCharacter) {
+            return visitor.visitCharacter(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Named_charContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    CHAR_NAMED() {
+        return this.getToken(ClojureParser.CHAR_NAMED, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_named_char;
+    }
+    accept(visitor) {
+        if (visitor.visitNamed_char) {
+            return visitor.visitNamed_char(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Any_charContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    CHAR_ANY() {
+        return this.getToken(ClojureParser.CHAR_ANY, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_any_char;
+    }
+    accept(visitor) {
+        if (visitor.visitAny_char) {
+            return visitor.visitAny_char(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class U_hex_quadContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    CHAR_U() {
+        return this.getToken(ClojureParser.CHAR_U, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_u_hex_quad;
+    }
+    accept(visitor) {
+        if (visitor.visitU_hex_quad) {
+            return visitor.visitU_hex_quad(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Nil_Context extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    NIL() {
+        return this.getToken(ClojureParser.NIL, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_nil_;
+    }
+    accept(visitor) {
+        if (visitor.visitNil_) {
+            return visitor.visitNil_(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class KeywordContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    macro_keyword() {
+        return this.getRuleContext(0, Macro_keywordContext);
+    }
+    simple_keyword() {
+        return this.getRuleContext(0, Simple_keywordContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_keyword;
+    }
+    accept(visitor) {
+        if (visitor.visitKeyword) {
+            return visitor.visitKeyword(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Simple_keywordContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    symbol() {
+        return this.getRuleContext(0, SymbolContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_simple_keyword;
+    }
+    accept(visitor) {
+        if (visitor.visitSimple_keyword) {
+            return visitor.visitSimple_keyword(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Macro_keywordContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    symbol() {
+        return this.getRuleContext(0, SymbolContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_macro_keyword;
+    }
+    accept(visitor) {
+        if (visitor.visitMacro_keyword) {
+            return visitor.visitMacro_keyword(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class SymbolContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    ns_symbol() {
+        return this.getRuleContext(0, Ns_symbolContext);
+    }
+    simple_sym() {
+        return this.getRuleContext(0, Simple_symContext);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_symbol;
+    }
+    accept(visitor) {
+        if (visitor.visitSymbol) {
+            return visitor.visitSymbol(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Simple_symContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    SYMBOL() {
+        return this.getToken(ClojureParser.SYMBOL, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_simple_sym;
+    }
+    accept(visitor) {
+        if (visitor.visitSimple_sym) {
+            return visitor.visitSimple_sym(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Ns_symbolContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    NS_SYMBOL() {
+        return this.getToken(ClojureParser.NS_SYMBOL, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_ns_symbol;
+    }
+    accept(visitor) {
+        if (visitor.visitNs_symbol) {
+            return visitor.visitNs_symbol(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class Param_nameContext extends antlr.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    PARAM_NAME() {
+        return this.getToken(ClojureParser.PARAM_NAME, 0);
+    }
+    get ruleIndex() {
+        return ClojureParser.RULE_param_name;
+    }
+    accept(visitor) {
+        if (visitor.visitParam_name) {
+            return visitor.visitParam_name(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+//# sourceMappingURL=ClojureParser.js.map