function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }

function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, _regeneratorDefine2(e, r, n, t); }

function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }

function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }

function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }

function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }

function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }

function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }

function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }

function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }

function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }

function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }

function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }

(window["webpackJsonp"] = window["webpackJsonp"] || []).push([["logstab-logstab-module"], {
  /***/
  "./node_modules/antlr4-autosuggest/antlr4-autosuggest.js":
  /*!***************************************************************!*\
    !*** ./node_modules/antlr4-autosuggest/antlr4-autosuggest.js ***!
    \***************************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4Autosuggest_antlr4AutosuggestJs(module, exports, __webpack_require__) {
    (function webpackUniversalModuleDefinition(root, factory) {
      if (true) module.exports = factory();else {}
    })(typeof self !== 'undefined' ? self : this, function () {
      return (
        /******/
        function (modules) {
          // webpackBootstrap

          /******/
          // The module cache

          /******/
          var installedModules = {};
          /******/

          /******/
          // The require function

          /******/

          function __webpack_require__(moduleId) {
            /******/

            /******/
            // Check if module is in cache

            /******/
            if (installedModules[moduleId]) {
              /******/
              return installedModules[moduleId].exports;
              /******/
            }
            /******/
            // Create a new module (and put it into the cache)

            /******/


            var module = installedModules[moduleId] = {
              /******/
              i: moduleId,

              /******/
              l: false,

              /******/
              exports: {}
              /******/

            };
            /******/

            /******/
            // Execute the module function

            /******/

            modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
            /******/

            /******/
            // Flag the module as loaded

            /******/

            module.l = true;
            /******/

            /******/
            // Return the exports of the module

            /******/

            return module.exports;
            /******/
          }
          /******/

          /******/

          /******/
          // expose the modules object (__webpack_modules__)

          /******/


          __webpack_require__.m = modules;
          /******/

          /******/
          // expose the module cache

          /******/

          __webpack_require__.c = installedModules;
          /******/

          /******/
          // define getter function for harmony exports

          /******/

          __webpack_require__.d = function (exports, name, getter) {
            /******/
            if (!__webpack_require__.o(exports, name)) {
              /******/
              Object.defineProperty(exports, name, {
                /******/
                configurable: false,

                /******/
                enumerable: true,

                /******/
                get: getter
                /******/

              });
              /******/
            }
            /******/

          };
          /******/

          /******/
          // getDefaultExport function for compatibility with non-harmony modules

          /******/


          __webpack_require__.n = function (module) {
            /******/
            var getter = module && module.__esModule ?
            /******/
            function getDefault() {
              return module['default'];
            } :
            /******/
            function getModuleExports() {
              return module;
            };
            /******/

            __webpack_require__.d(getter, 'a', getter);
            /******/


            return getter;
            /******/
          };
          /******/

          /******/
          // Object.prototype.hasOwnProperty.call

          /******/


          __webpack_require__.o = function (object, property) {
            return Object.prototype.hasOwnProperty.call(object, property);
          };
          /******/

          /******/
          // __webpack_public_path__

          /******/


          __webpack_require__.p = "";
          /******/

          /******/
          // Load entry module and return exports

          /******/

          return __webpack_require__(__webpack_require__.s = 2);
          /******/
        }
        /************************************************************************/

        /******/
        ([
        /* 0 */

        /***/
        function (module, exports) {
          module.exports = __webpack_require__(
          /*! debug */
          "./node_modules/debug/src/browser.js");
          /***/
        },
        /* 1 */

        /***/
        function (module, exports, __webpack_require__) {
          "use strict"; // Useful constants for working with Antlr4 ATNs that are not made public by the runtime

          var ATOM_TRANSITION = 5;
          var SET_TRANSITION = 7;
          exports.ATOM_TRANSITION = ATOM_TRANSITION;
          exports.SET_TRANSITION = SET_TRANSITION;
          /***/
        },
        /* 2 */

        /***/
        function (module, exports, __webpack_require__) {
          "use strict";

          var antlr4 = __webpack_require__(3);

          var TokenSuggester = __webpack_require__(4);

          var debug = __webpack_require__(0)('autosuggest');

          var constants = __webpack_require__(1);

          function AutoSuggestionsGenerator(lexerAndParserFactory, input) {
            this._lexerAndParserFactory = lexerAndParserFactory;
            this._input = input;
            this._inputTokens = [];
            this._untokenizedText = '';
            this._parserAtn = null;
            this._parserRuleNames = [];
            this._indent = '';
            this._collectedSuggestions = [];
            this._casePreference = 'BOTH';
            this._parserStateToTokenListIndexWhereLastVisited = new Map();
            return this;
          }

          var transToStr = function transToStr(trans) {
            return '' + trans.constructor.name + '->' + trans.target;
          };

          AutoSuggestionsGenerator.prototype.constructor = AutoSuggestionsGenerator;

          AutoSuggestionsGenerator.prototype.suggest = function () {
            this._tokenizeInput();

            this._storeParserAtnAndRuleNames();

            this._runParserAtnAndCollectSuggestions();

            return this._collectedSuggestions;
          };

          AutoSuggestionsGenerator.prototype.setCasePreference = function (casePreference) {
            this._casePreference = casePreference;
          };

          AutoSuggestionsGenerator.prototype._tokenizeInput = function () {
            var lexer = this._createLexerWithUntokenizedTextDetection();

            var allTokens = lexer.getAllTokens(); // side effect: also fills this.untokenizedText

            this._inputTokens = this._filterOutNonDefaultChannels(allTokens);
            debug('TOKENS FOUND IN FIRST PASS:');
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
              for (var _iterator = this._inputTokens[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var token = _step.value;
                debug('' + token);
              }
            } catch (err) {
              _didIteratorError = true;
              _iteratorError = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion && _iterator["return"]) {
                  _iterator["return"]();
                }
              } finally {
                if (_didIteratorError) {
                  throw _iteratorError;
                }
              }
            }

            debug('UNTOKENIZED: ' + this._untokenizedText);
          };

          AutoSuggestionsGenerator.prototype._filterOutNonDefaultChannels = function (tokens) {
            return tokens.filter(function (token) {
              return token.channel === 0;
            });
          };

          AutoSuggestionsGenerator.prototype._createLexerWithUntokenizedTextDetection = function () {
            var lexer = this._createDefaultLexer();

            lexer.removeErrorListeners();
            var self = this;
            var newErrorListener = Object.create(antlr4.error.ErrorListener);

            newErrorListener.syntaxError = function (recognizer, offendingSymbol, line, column, msg, e) {
              self._untokenizedText = self._input.substring(column);
            };

            lexer.addErrorListener(newErrorListener);
            return lexer;
          };

          AutoSuggestionsGenerator.prototype._createDefaultLexer = function () {
            return this._createLexer(this._input);
          };

          AutoSuggestionsGenerator.prototype._createLexer = function (lexerInput) {
            var inputStream = new antlr4.InputStream(lexerInput);

            var lexer = this._lexerAndParserFactory.createLexer(inputStream);

            return lexer;
          };

          AutoSuggestionsGenerator.prototype._storeParserAtnAndRuleNames = function () {
            var tokenStream = new antlr4.CommonTokenStream(this._createDefaultLexer());

            var parser = this._lexerAndParserFactory.createParser(tokenStream);

            debug('Parser rule names: ' + parser.ruleNames.join(', '));
            this._parserAtn = parser.atn;
            this._parserRuleNames = parser.ruleNames;
          };

          AutoSuggestionsGenerator.prototype._runParserAtnAndCollectSuggestions = function () {
            var initialState = this._parserAtn.states[0];

            this._parseAndCollectTokenSuggestions(initialState, 0);
          };

          AutoSuggestionsGenerator.prototype._parseAndCollectTokenSuggestions = function (parserState, tokenListIndex) {
            var prevIndent = this._indent;
            this._indent += '  ';

            if (this._didVisitParserStateOnThisTokenIndex(parserState, tokenListIndex)) {
              debug(this._indent + "State " + parserState + " had already been visited while processing token " + tokenListIndex + ", backtracking to avoid infinite loop.");
              return;
            }

            var previousTokenListIndexForThisState = this._setParserStateLastVisitedOnThisTokenIndex(parserState, tokenListIndex);

            try {
              debug(this._indent + 'State: ' + parserState + ' (type: ' + parserState.constructor.name + ')'); // debug(indent + 'State available transitions: ' + transitionsStr(parserState));

              if (!this._haveMoreTokens(tokenListIndex)) {
                // stop condition for recursion
                this._suggestNextTokensForParserState(parserState);

                return;
              }

              var _iteratorNormalCompletion2 = true;
              var _didIteratorError2 = false;
              var _iteratorError2 = undefined;

              try {
                for (var _iterator2 = parserState.transitions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                  var trans = _step2.value;

                  if (trans.isEpsilon) {
                    this._handleEpsilonTransition(trans, tokenListIndex);
                  } else if (trans.serializationType === constants.ATOM_TRANSITION) {
                    this._handleAtomicTransition(trans, tokenListIndex);
                  } else {
                    this._handleSetTransition(trans, tokenListIndex);
                  }
                }
              } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
              } finally {
                try {
                  if (!_iteratorNormalCompletion2 && _iterator2["return"]) {
                    _iterator2["return"]();
                  }
                } finally {
                  if (_didIteratorError2) {
                    throw _iteratorError2;
                  }
                }
              }
            } finally {
              this._indent = prevIndent;

              this._setParserStateLastVisitedOnThisTokenIndex(parserState, previousTokenListIndexForThisState);
            }
          };

          AutoSuggestionsGenerator.prototype._didVisitParserStateOnThisTokenIndex = function (parserState, currentTokenListIndex) {
            var lastVisitedThisStateAtTokenListIndex = this._parserStateToTokenListIndexWhereLastVisited.get(parserState);

            return currentTokenListIndex === lastVisitedThisStateAtTokenListIndex;
          };

          AutoSuggestionsGenerator.prototype._setParserStateLastVisitedOnThisTokenIndex = function (parserState, tokenListIndex) {
            var previous = this._parserStateToTokenListIndexWhereLastVisited.get(parserState);

            if (typeof tokenListIndex === 'undefined') {
              this._parserStateToTokenListIndexWhereLastVisited["delete"](parserState);
            } else {
              this._parserStateToTokenListIndexWhereLastVisited.set(parserState, tokenListIndex);
            }

            return previous;
          };

          AutoSuggestionsGenerator.prototype._haveMoreTokens = function (index) {
            return index < this._inputTokens.length;
          };

          AutoSuggestionsGenerator.prototype._handleEpsilonTransition = function (trans, tokenListIndex) {
            this._parseAndCollectTokenSuggestions(trans.target, tokenListIndex);
          };

          AutoSuggestionsGenerator.prototype._handleAtomicTransition = function (trans, tokenListIndex) {
            var nextToken = this._inputTokens.slice(tokenListIndex, tokenListIndex + 1)[0];

            var nextTokenType = nextToken.type;
            var nextTokenMatchesTransition = trans.label.contains(nextTokenType);

            if (nextTokenMatchesTransition) {
              this._parseAndCollectTokenSuggestions(trans.target, tokenListIndex + 1);
            }
          };

          AutoSuggestionsGenerator.prototype._handleSetTransition = function (trans, tokenListIndex) {
            var nextToken = this._inputTokens.slice(tokenListIndex, tokenListIndex + 1)[0];

            var nextTokenType = nextToken.type;
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
              for (var _iterator3 = trans.label.intervals[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                var interval = _step3.value;

                for (var transitionTokenType = interval.start; transitionTokenType <= interval.stop; ++transitionTokenType) {
                  var nextTokenMatchesTransition = transitionTokenType === nextTokenType;

                  if (nextTokenMatchesTransition) {
                    debug(this._indent + 'Token ' + nextToken + ' following transition: ' + transToStr(trans) + ' to ' + transitionTokenType);

                    this._parseAndCollectTokenSuggestions(trans.target, tokenListIndex + 1);
                  } else {
                    debug(this._indent + 'Token ' + nextToken + ' NOT following transition: ' + transToStr(trans) + ' to ' + transitionTokenType);
                  }
                }
              }
            } catch (err) {
              _didIteratorError3 = true;
              _iteratorError3 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion3 && _iterator3["return"]) {
                  _iterator3["return"]();
                }
              } finally {
                if (_didIteratorError3) {
                  throw _iteratorError3;
                }
              }
            }
          };

          AutoSuggestionsGenerator.prototype._suggestNextTokensForParserState = function (parserState) {
            var transitionLabels = new Set();

            this._fillParserTransitionLabels(parserState, transitionLabels, new Set());

            var tokenSuggester = new TokenSuggester.TokenSuggester(this._createDefaultLexer(), this._casePreference);
            var suggestions = tokenSuggester.suggest(transitionLabels, this._untokenizedText);

            this._parseSuggestionsAndAddValidOnes(parserState, suggestions); // logger.debug(indent + 'WILL SUGGEST TOKENS FOR STATE: ' + parserState);

          };

          var toTransKey = function toTransKey(src, trans) {
            return '' + src.stateNumber + '->(' + trans.serializationType + ') ' + trans.target.stateNumber;
          };

          AutoSuggestionsGenerator.prototype._fillParserTransitionLabels = function (parserState, result, visitedTransitions) {
            var _iteratorNormalCompletion4 = true;
            var _didIteratorError4 = false;
            var _iteratorError4 = undefined;

            try {
              for (var _iterator4 = parserState.transitions[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                var trans = _step4.value;
                var transKey = toTransKey(parserState, trans);

                if (visitedTransitions.has(transKey)) {
                  debug(this._indent + 'Not following visited ' + transKey);
                  return;
                }

                if (trans.isEpsilon) {
                  visitedTransitions.add(transKey);

                  try {
                    this._fillParserTransitionLabels(trans.target, result, visitedTransitions);
                  } finally {
                    visitedTransitions["delete"](transKey);
                  }
                } else if (trans.serializationType === constants.ATOM_TRANSITION) {
                  result.add(trans.label_);
                } else if (trans.serializationType === constants.SET_TRANSITION) {
                  var _iteratorNormalCompletion5 = true;
                  var _didIteratorError5 = false;
                  var _iteratorError5 = undefined;

                  try {
                    for (var _iterator5 = trans.label.intervals[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                      var interval = _step5.value;

                      for (var i = interval.start; i < interval.stop; ++i) {
                        result.add(i);
                      }
                    }
                  } catch (err) {
                    _didIteratorError5 = true;
                    _iteratorError5 = err;
                  } finally {
                    try {
                      if (!_iteratorNormalCompletion5 && _iterator5["return"]) {
                        _iterator5["return"]();
                      }
                    } finally {
                      if (_didIteratorError5) {
                        throw _iteratorError5;
                      }
                    }
                  }

                  ;
                }
              }
            } catch (err) {
              _didIteratorError4 = true;
              _iteratorError4 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion4 && _iterator4["return"]) {
                  _iterator4["return"]();
                }
              } finally {
                if (_didIteratorError4) {
                  throw _iteratorError4;
                }
              }
            }

            ;
          };

          AutoSuggestionsGenerator.prototype._parseSuggestionsAndAddValidOnes = function (parserState, suggestions) {
            var _iteratorNormalCompletion6 = true;
            var _didIteratorError6 = false;
            var _iteratorError6 = undefined;

            try {
              for (var _iterator6 = suggestions[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
                var suggestion = _step6.value;

                var addedToken = this._getAddedToken(suggestion);

                if (this._isParseableWithAddedToken(parserState, addedToken, new Set())) {
                  if (!this._collectedSuggestions.includes(suggestion)) {
                    this._collectedSuggestions.push(suggestion);
                  }
                } else {
                  debug('DROPPING non-parseable suggestion: ' + suggestion);
                }
              }
            } catch (err) {
              _didIteratorError6 = true;
              _iteratorError6 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion6 && _iterator6["return"]) {
                  _iterator6["return"]();
                }
              } finally {
                if (_didIteratorError6) {
                  throw _iteratorError6;
                }
              }
            }

            ;
          };

          AutoSuggestionsGenerator.prototype._getAddedToken = function (suggestedCompletion) {
            var completedText = this._input + suggestedCompletion;

            var completedTextLexer = this._createLexer(completedText);

            completedTextLexer.removeErrorListeners();

            var completedTextTokens = this._filterOutNonDefaultChannels(completedTextLexer.getAllTokens());

            if (completedTextTokens.length <= this._inputTokens.length) {
              return null; // Completion didn't yield whole token, could be just a token fragment
            }

            var newToken = completedTextTokens[completedTextTokens.length - 1];
            return newToken;
          };

          AutoSuggestionsGenerator.prototype._isParseableWithAddedToken = function (parserState, newToken, visitedTransitions) {
            if (newToken == null) {
              return false;
            }

            var parseable = false;
            var _iteratorNormalCompletion7 = true;
            var _didIteratorError7 = false;
            var _iteratorError7 = undefined;

            try {
              for (var _iterator7 = parserState.transitions[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
                var parserTransition = _step7.value;

                if (parserTransition.isEpsilon) {
                  // Recurse through any epsilon transitions
                  var transKey = toTransKey(parserState, parserTransition);

                  if (visitedTransitions.has(transKey)) {
                    debug(this._indent + 'Not following visited ' + transKey);
                    return;
                  }

                  visitedTransitions.add(transKey);

                  try {
                    if (this._isParseableWithAddedToken(parserTransition.target, newToken, visitedTransitions)) {
                      parseable = true;
                    }
                  } finally {
                    visitedTransitions["delete"](transKey);
                  }
                } else if (parserTransition.serializationType === constants.ATOM_TRANSITION) {
                  var transitionTokenType = parserTransition.label;

                  if (transitionTokenType.first() === newToken.type) {
                    parseable = true;
                  }
                } else if (parserTransition.serializationType === constants.SET_TRANSITION) {
                  var _iteratorNormalCompletion8 = true;
                  var _didIteratorError8 = false;
                  var _iteratorError8 = undefined;

                  try {
                    for (var _iterator8 = parserTransition.label.intervals[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
                      var interval = _step8.value;

                      for (var _transitionTokenType = interval.start; _transitionTokenType <= interval.stop; ++_transitionTokenType) {
                        if (_transitionTokenType === newToken.type) {
                          parseable = true;
                        }
                      }
                    }
                  } catch (err) {
                    _didIteratorError8 = true;
                    _iteratorError8 = err;
                  } finally {
                    try {
                      if (!_iteratorNormalCompletion8 && _iterator8["return"]) {
                        _iterator8["return"]();
                      }
                    } finally {
                      if (_didIteratorError8) {
                        throw _iteratorError8;
                      }
                    }
                  }

                  ;
                } else {
                  throw 'Unexpected: ' + transToStr(parserTransition);
                }
              }
            } catch (err) {
              _didIteratorError7 = true;
              _iteratorError7 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion7 && _iterator7["return"]) {
                  _iterator7["return"]();
                }
              } finally {
                if (_didIteratorError7) {
                  throw _iteratorError7;
                }
              }
            }

            ;
            return parseable;
          };

          function AutoSuggester(lexerCtr, parserCtr) {
            var casePreference = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
            this._lexerCtr = lexerCtr;
            this._parserCtr = parserCtr;
            this._casePreference = casePreference;

            this._assertLexerHasAtn();

            return this;
          }

          AutoSuggester.prototype.constructor = AutoSuggester;

          AutoSuggester.prototype.createLexer = function (input) {
            return new this._lexerCtr(input);
          };

          AutoSuggester.prototype.createParser = function (tokenStream) {
            return new this._parserCtr(tokenStream);
          };

          AutoSuggester.prototype.autosuggest = function (inputText) {
            var generator = new AutoSuggestionsGenerator(this, inputText);
            debug("CASE_PREF : " + this._casePreference);

            if (this._casePreference) {
              generator.setCasePreference(this._casePreference);
            }

            return generator.suggest();
          };

          AutoSuggester.prototype._assertLexerHasAtn = function () {
            var lexer = new this._lexerCtr(null);

            if (typeof lexer.atn === 'undefined') {
              throw "Please use ANTLR4 version 4.7.1 or above.";
            }

            return lexer;
          };

          var autosuggester = function autosuggester(lexerCtr, parserCtr) {
            var casePref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
            return new AutoSuggester(lexerCtr, parserCtr, casePref);
          };

          module.exports.autosuggester = autosuggester;
          /***/
        },
        /* 3 */

        /***/
        function (module, exports) {
          module.exports = __webpack_require__(
          /*! antlr4 */
          "./node_modules/antlr4/index.js");
          /***/
        },
        /* 4 */

        /***/
        function (module, exports, __webpack_require__) {
          "use strict";

          var debug = __webpack_require__(0)('tokensuggester');

          var constants = __webpack_require__(1);

          function TokenSuggester(lexer) {
            var casePreference = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
            this._lexer = lexer;
            this._suggestions = [];
            this._visitedLexerStates = [];
            this._origPartialToken = '';
            this._casePreference = casePreference;
            return this;
          }

          TokenSuggester.prototype.constructor = TokenSuggester;

          TokenSuggester.prototype.suggest = function (nextParserTransitionLabels, remainingText) {
            debug("Suggesting tokens for rule numbers: " + nextParserTransitionLabels);
            this._origPartialToken = remainingText;
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
              for (var _iterator = nextParserTransitionLabels[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var nextParserTransitionLabel = _step.value;
                var nextTokenRuleNumber = nextParserTransitionLabel - 1; // Count from 0 not from 1

                var lexerState = this._findLexerStateByRuleNumber(nextTokenRuleNumber);

                this._suggest('', lexerState, remainingText);
              }
            } catch (err) {
              _didIteratorError = true;
              _iteratorError = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion && _iterator["return"]) {
                  _iterator["return"]();
                }
              } finally {
                if (_didIteratorError) {
                  throw _iteratorError;
                }
              }
            }

            return this._suggestions;
          };

          TokenSuggester.prototype._findLexerStateByRuleNumber = function (ruleNumber) {
            return this._lexer.atn.ruleToStartState.slice(ruleNumber, ruleNumber + 1)[0];
          };

          TokenSuggester.prototype._suggest = function (tokenSoFar, lexerState, remainingText) {
            debug('SUGGEST: tokenSoFar=' + tokenSoFar + ' remainingText=' + remainingText + ' lexerState=' + lexerState);

            if (this._visitedLexerStates.includes(lexerState.stateNumber)) {
              return; // avoid infinite loop and stack overflow
            }

            this._visitedLexerStates.push(lexerState.stateNumber);

            try {
              var tokenNotEmpty = tokenSoFar.length > 0;
              var noMoreCharactersInToken = lexerState.transitions.length === 0;

              if (tokenNotEmpty && noMoreCharactersInToken) {
                this._addSuggestedToken(tokenSoFar);
              }

              var _iteratorNormalCompletion2 = true;
              var _didIteratorError2 = false;
              var _iteratorError2 = undefined;

              try {
                for (var _iterator2 = lexerState.transitions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                  var trans = _step2.value;

                  this._suggestViaLexerTransition(tokenSoFar, remainingText, trans);
                }
              } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
              } finally {
                try {
                  if (!_iteratorNormalCompletion2 && _iterator2["return"]) {
                    _iterator2["return"]();
                  }
                } finally {
                  if (_didIteratorError2) {
                    throw _iteratorError2;
                  }
                }
              }
            } finally {
              this._visitedLexerStates.pop();
            }
          };

          var _calcAllLabelChars = function _calcAllLabelChars(label) {
            var allLabelChars = [];
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
              for (var _iterator3 = label.intervals[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                var interval = _step3.value;

                for (var codePoint = interval.start; codePoint < interval.stop; ++codePoint) {
                  allLabelChars.push(String.fromCharCode(codePoint));
                }
              }
            } catch (err) {
              _didIteratorError3 = true;
              _iteratorError3 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion3 && _iterator3["return"]) {
                  _iterator3["return"]();
                }
              } finally {
                if (_didIteratorError3) {
                  throw _iteratorError3;
                }
              }
            }

            return allLabelChars;
          };

          TokenSuggester.prototype._suggestViaLexerTransition = function (tokenSoFar, remainingText, trans) {
            if (trans.isEpsilon) {
              this._suggest(tokenSoFar, trans.target, remainingText);
            } else if (trans.serializationType === constants.ATOM_TRANSITION) {
              var newTokenChar = this._getAddedTextFor(trans);

              if (remainingText === '' || remainingText.startsWith(newTokenChar)) {
                debug("LEXER TOKEN: " + newTokenChar + " remaining=" + remainingText);

                this._suggestViaNonEpsilonLexerTransition(tokenSoFar, remainingText, newTokenChar, trans.target);
              } else {
                debug("NONMATCHING LEXER TOKEN: " + newTokenChar + " remaining=" + remainingText);
              }
            } else if (trans.serializationType === constants.SET_TRANSITION) {
              var allLabelChars = _calcAllLabelChars(trans.label);

              var _iteratorNormalCompletion4 = true;
              var _didIteratorError4 = false;
              var _iteratorError4 = undefined;

              try {
                for (var _iterator4 = trans.label.intervals[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                  var interval = _step4.value;

                  for (var codePoint = interval.start; codePoint <= interval.stop; ++codePoint) {
                    var ch = String.fromCodePoint(codePoint);

                    var shouldIgnoreCase = this._shouldIgnoreThisCase(ch, allLabelChars);

                    var _newTokenChar = String.fromCodePoint(codePoint);

                    if (!shouldIgnoreCase && (remainingText === '' || remainingText.startsWith(_newTokenChar))) {
                      this._suggestViaNonEpsilonLexerTransition(tokenSoFar, remainingText, _newTokenChar, trans.target);
                    }
                  }
                }
              } catch (err) {
                _didIteratorError4 = true;
                _iteratorError4 = err;
              } finally {
                try {
                  if (!_iteratorNormalCompletion4 && _iterator4["return"]) {
                    _iterator4["return"]();
                  }
                } finally {
                  if (_didIteratorError4) {
                    throw _iteratorError4;
                  }
                }
              }
            }
          };

          TokenSuggester.prototype._suggestViaNonEpsilonLexerTransition = function (tokenSoFar, remainingText, newTokenChar, targetState) {
            var newRemainingText = remainingText.length > 0 ? remainingText.substr(1) : '';

            this._suggest(tokenSoFar + newTokenChar, targetState, newRemainingText);
          };

          TokenSuggester.prototype._addSuggestedToken = function (tokenToAdd) {
            var justTheCompletionPart = this._chopOffCommonStart(tokenToAdd, this._origPartialToken);

            if (!this._suggestions.includes(justTheCompletionPart)) {
              debug("SUGGESTIONG: " + justTheCompletionPart);

              this._suggestions.push(justTheCompletionPart);
            }
          };

          TokenSuggester.prototype._chopOffCommonStart = function (a, b) {
            var charsToChopOff = Math.min(a.length, b.length);
            return a.substr(charsToChopOff, a.length - charsToChopOff);
          };

          TokenSuggester.prototype._getAddedTextFor = function (transition) {
            return String.fromCodePoint(transition.label);
          };

          TokenSuggester.prototype._shouldIgnoreThisCase = function (transChar, allTransChars) {
            if (this._casePreference == null || this._casePreference === 'BOTH') {
              return false;
            }

            var upper = transChar.toUpperCase();
            var lower = transChar.toLowerCase();

            switch (this._casePreference) {
              case 'LOWER':
                return transChar === upper && allTransChars.includes(lower);

              case 'UPPER':
                return transChar === lower && allTransChars.includes(upper);

              default:
                return false;
            }
          };

          exports.TokenSuggester = TokenSuggester;
          /***/
        }
        /******/
        ])
      );
    });
    /***/

  },

  /***/
  "./node_modules/antlr4/BufferedTokenStream.js":
  /*!****************************************************!*\
    !*** ./node_modules/antlr4/BufferedTokenStream.js ***!
    \****************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_BufferedTokenStreamJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    // This implementation of {@link TokenStream} loads tokens from a
    // {@link TokenSource} on-demand, and places the tokens in a buffer to provide
    // access to any previous token by index.
    //
    // <p>
    // This token stream ignores the value of {@link Token//getChannel}. If your
    // parser requires the token stream filter tokens to only those on a particular
    // channel, such as {@link Token//DEFAULT_CHANNEL} or
    // {@link Token//HIDDEN_CHANNEL}, use a filtering token stream such a
    // {@link CommonTokenStream}.</p>
    var Token = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").Token;

    var Lexer = __webpack_require__(
    /*! ./Lexer */
    "./node_modules/antlr4/Lexer.js").Lexer;

    var Interval = __webpack_require__(
    /*! ./IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval; // this is just to keep meaningful parameter types to Parser


    function TokenStream() {
      return this;
    }

    function BufferedTokenStream(tokenSource) {
      TokenStream.call(this); // The {@link TokenSource} from which tokens for this stream are fetched.

      this.tokenSource = tokenSource; // A collection of all tokens fetched from the token source. The list is
      // considered a complete view of the input once {@link //fetchedEOF} is set
      // to {@code true}.

      this.tokens = []; // The index into {@link //tokens} of the current token (next token to
      // {@link //consume}). {@link //tokens}{@code [}{@link //p}{@code ]} should
      // be
      // {@link //LT LT(1)}.
      //
      // <p>This field is set to -1 when the stream is first constructed or when
      // {@link //setTokenSource} is called, indicating that the first token has
      // not yet been fetched from the token source. For additional information,
      // see the documentation of {@link IntStream} for a description of
      // Initializing Methods.</p>

      this.index = -1; // Indicates whether the {@link Token//EOF} token has been fetched from
      // {@link //tokenSource} and added to {@link //tokens}. This field improves
      // performance for the following cases:
      //
      // <ul>
      // <li>{@link //consume}: The lookahead check in {@link //consume} to
      // prevent
      // consuming the EOF symbol is optimized by checking the values of
      // {@link //fetchedEOF} and {@link //p} instead of calling {@link
      // //LA}.</li>
      // <li>{@link //fetch}: The check to prevent adding multiple EOF symbols
      // into
      // {@link //tokens} is trivial with this field.</li>
      // <ul>

      this.fetchedEOF = false;
      return this;
    }

    BufferedTokenStream.prototype = Object.create(TokenStream.prototype);
    BufferedTokenStream.prototype.constructor = BufferedTokenStream;

    BufferedTokenStream.prototype.mark = function () {
      return 0;
    };

    BufferedTokenStream.prototype.release = function (marker) {// no resources to release
    };

    BufferedTokenStream.prototype.reset = function () {
      this.seek(0);
    };

    BufferedTokenStream.prototype.seek = function (index) {
      this.lazyInit();
      this.index = this.adjustSeekIndex(index);
    };

    BufferedTokenStream.prototype.get = function (index) {
      this.lazyInit();
      return this.tokens[index];
    };

    BufferedTokenStream.prototype.consume = function () {
      var skipEofCheck = false;

      if (this.index >= 0) {
        if (this.fetchedEOF) {
          // the last token in tokens is EOF. skip check if p indexes any
          // fetched token except the last.
          skipEofCheck = this.index < this.tokens.length - 1;
        } else {
          // no EOF token in tokens. skip check if p indexes a fetched token.
          skipEofCheck = this.index < this.tokens.length;
        }
      } else {
        // not yet initialized
        skipEofCheck = false;
      }

      if (!skipEofCheck && this.LA(1) === Token.EOF) {
        throw "cannot consume EOF";
      }

      if (this.sync(this.index + 1)) {
        this.index = this.adjustSeekIndex(this.index + 1);
      }
    }; // Make sure index {@code i} in tokens has a token.
    //
    // @return {@code true} if a token is located at index {@code i}, otherwise
    // {@code false}.
    // @see //get(int i)
    // /


    BufferedTokenStream.prototype.sync = function (i) {
      var n = i - this.tokens.length + 1; // how many more elements we need?

      if (n > 0) {
        var fetched = this.fetch(n);
        return fetched >= n;
      }

      return true;
    }; // Add {@code n} elements to buffer.
    //
    // @return The actual number of elements added to the buffer.
    // /


    BufferedTokenStream.prototype.fetch = function (n) {
      if (this.fetchedEOF) {
        return 0;
      }

      for (var i = 0; i < n; i++) {
        var t = this.tokenSource.nextToken();
        t.tokenIndex = this.tokens.length;
        this.tokens.push(t);

        if (t.type === Token.EOF) {
          this.fetchedEOF = true;
          return i + 1;
        }
      }

      return n;
    }; // Get all tokens from start..stop inclusively///


    BufferedTokenStream.prototype.getTokens = function (start, stop, types) {
      if (types === undefined) {
        types = null;
      }

      if (start < 0 || stop < 0) {
        return null;
      }

      this.lazyInit();
      var subset = [];

      if (stop >= this.tokens.length) {
        stop = this.tokens.length - 1;
      }

      for (var i = start; i < stop; i++) {
        var t = this.tokens[i];

        if (t.type === Token.EOF) {
          break;
        }

        if (types === null || types.contains(t.type)) {
          subset.push(t);
        }
      }

      return subset;
    };

    BufferedTokenStream.prototype.LA = function (i) {
      return this.LT(i).type;
    };

    BufferedTokenStream.prototype.LB = function (k) {
      if (this.index - k < 0) {
        return null;
      }

      return this.tokens[this.index - k];
    };

    BufferedTokenStream.prototype.LT = function (k) {
      this.lazyInit();

      if (k === 0) {
        return null;
      }

      if (k < 0) {
        return this.LB(-k);
      }

      var i = this.index + k - 1;
      this.sync(i);

      if (i >= this.tokens.length) {
        // return EOF token
        // EOF must be last token
        return this.tokens[this.tokens.length - 1];
      }

      return this.tokens[i];
    }; // Allowed derived classes to modify the behavior of operations which change
    // the current stream position by adjusting the target token index of a seek
    // operation. The default implementation simply returns {@code i}. If an
    // exception is thrown in this method, the current stream index should not be
    // changed.
    //
    // <p>For example, {@link CommonTokenStream} overrides this method to ensure
    // that
    // the seek target is always an on-channel token.</p>
    //
    // @param i The target token index.
    // @return The adjusted target token index.


    BufferedTokenStream.prototype.adjustSeekIndex = function (i) {
      return i;
    };

    BufferedTokenStream.prototype.lazyInit = function () {
      if (this.index === -1) {
        this.setup();
      }
    };

    BufferedTokenStream.prototype.setup = function () {
      this.sync(0);
      this.index = this.adjustSeekIndex(0);
    }; // Reset this token stream by setting its token source.///


    BufferedTokenStream.prototype.setTokenSource = function (tokenSource) {
      this.tokenSource = tokenSource;
      this.tokens = [];
      this.index = -1;
      this.fetchedEOF = false;
    }; // Given a starting index, return the index of the next token on channel.
    // Return i if tokens[i] is on channel. Return -1 if there are no tokens
    // on channel between i and EOF.
    // /


    BufferedTokenStream.prototype.nextTokenOnChannel = function (i, channel) {
      this.sync(i);

      if (i >= this.tokens.length) {
        return -1;
      }

      var token = this.tokens[i];

      while (token.channel !== this.channel) {
        if (token.type === Token.EOF) {
          return -1;
        }

        i += 1;
        this.sync(i);
        token = this.tokens[i];
      }

      return i;
    }; // Given a starting index, return the index of the previous token on channel.
    // Return i if tokens[i] is on channel. Return -1 if there are no tokens
    // on channel between i and 0.


    BufferedTokenStream.prototype.previousTokenOnChannel = function (i, channel) {
      while (i >= 0 && this.tokens[i].channel !== channel) {
        i -= 1;
      }

      return i;
    }; // Collect all tokens on specified channel to the right of
    // the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or
    // EOF. If channel is -1, find any non default channel token.


    BufferedTokenStream.prototype.getHiddenTokensToRight = function (tokenIndex, channel) {
      if (channel === undefined) {
        channel = -1;
      }

      this.lazyInit();

      if (tokenIndex < 0 || tokenIndex >= this.tokens.length) {
        throw "" + tokenIndex + " not in 0.." + this.tokens.length - 1;
      }

      var nextOnChannel = this.nextTokenOnChannel(tokenIndex + 1, Lexer.DEFAULT_TOKEN_CHANNEL);
      var from_ = tokenIndex + 1; // if none onchannel to right, nextOnChannel=-1 so set to = last token

      var to = nextOnChannel === -1 ? this.tokens.length - 1 : nextOnChannel;
      return this.filterForChannel(from_, to, channel);
    }; // Collect all tokens on specified channel to the left of
    // the current token up until we see a token on DEFAULT_TOKEN_CHANNEL.
    // If channel is -1, find any non default channel token.


    BufferedTokenStream.prototype.getHiddenTokensToLeft = function (tokenIndex, channel) {
      if (channel === undefined) {
        channel = -1;
      }

      this.lazyInit();

      if (tokenIndex < 0 || tokenIndex >= this.tokens.length) {
        throw "" + tokenIndex + " not in 0.." + this.tokens.length - 1;
      }

      var prevOnChannel = this.previousTokenOnChannel(tokenIndex - 1, Lexer.DEFAULT_TOKEN_CHANNEL);

      if (prevOnChannel === tokenIndex - 1) {
        return null;
      } // if none on channel to left, prevOnChannel=-1 then from=0


      var from_ = prevOnChannel + 1;
      var to = tokenIndex - 1;
      return this.filterForChannel(from_, to, channel);
    };

    BufferedTokenStream.prototype.filterForChannel = function (left, right, channel) {
      var hidden = [];

      for (var i = left; i < right + 1; i++) {
        var t = this.tokens[i];

        if (channel === -1) {
          if (t.channel !== Lexer.DEFAULT_TOKEN_CHANNEL) {
            hidden.push(t);
          }
        } else if (t.channel === channel) {
          hidden.push(t);
        }
      }

      if (hidden.length === 0) {
        return null;
      }

      return hidden;
    };

    BufferedTokenStream.prototype.getSourceName = function () {
      return this.tokenSource.getSourceName();
    }; // Get the text of all tokens in this buffer.///


    BufferedTokenStream.prototype.getText = function (interval) {
      this.lazyInit();
      this.fill();

      if (interval === undefined || interval === null) {
        interval = new Interval(0, this.tokens.length - 1);
      }

      var start = interval.start;

      if (start instanceof Token) {
        start = start.tokenIndex;
      }

      var stop = interval.stop;

      if (stop instanceof Token) {
        stop = stop.tokenIndex;
      }

      if (start === null || stop === null || start < 0 || stop < 0) {
        return "";
      }

      if (stop >= this.tokens.length) {
        stop = this.tokens.length - 1;
      }

      var s = "";

      for (var i = start; i < stop + 1; i++) {
        var t = this.tokens[i];

        if (t.type === Token.EOF) {
          break;
        }

        s = s + t.text;
      }

      return s;
    }; // Get all tokens from lexer until EOF///


    BufferedTokenStream.prototype.fill = function () {
      this.lazyInit();

      while (this.fetch(1000) === 1000) {
        continue;
      }
    };

    exports.BufferedTokenStream = BufferedTokenStream;
    /***/
  },

  /***/
  "./node_modules/antlr4/CharStreams.js":
  /*!********************************************!*\
    !*** ./node_modules/antlr4/CharStreams.js ***!
    \********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_CharStreamsJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    var InputStream = __webpack_require__(
    /*! ./InputStream */
    "./node_modules/antlr4/InputStream.js").InputStream;

    var isNodeJs = typeof window === 'undefined' && typeof importScripts === 'undefined';
    var fs = isNodeJs ? __webpack_require__(
    /*! fs */
    8) : null; // Utility functions to create InputStreams from various sources.
    //
    // All returned InputStreams support the full range of Unicode
    // up to U+10FFFF (the default behavior of InputStream only supports
    // code points up to U+FFFF).

    var CharStreams = {
      // Creates an InputStream from a string.
      fromString: function fromString(str) {
        return new InputStream(str, true);
      },
      // Asynchronously creates an InputStream from a blob given the
      // encoding of the bytes in that blob (defaults to 'utf8' if
      // encoding is null).
      //
      // Invokes onLoad(result) on success, onError(error) on
      // failure.
      fromBlob: function fromBlob(blob, encoding, onLoad, onError) {
        var reader = FileReader();

        reader.onload = function (e) {
          var is = new InputStream(e.target.result, true);
          onLoad(is);
        };

        reader.onerror = onError;
        reader.readAsText(blob, encoding);
      },
      // Creates an InputStream from a Buffer given the
      // encoding of the bytes in that buffer (defaults to 'utf8' if
      // encoding is null).
      fromBuffer: function fromBuffer(buffer, encoding) {
        return new InputStream(buffer.toString(encoding), true);
      },
      // Asynchronously creates an InputStream from a file on disk given
      // the encoding of the bytes in that file (defaults to 'utf8' if
      // encoding is null).
      //
      // Invokes callback(error, result) on completion.
      fromPath: function fromPath(path, encoding, callback) {
        fs.readFile(path, encoding, function (err, data) {
          var is = null;

          if (data !== null) {
            is = new InputStream(data, true);
          }

          callback(err, is);
        });
      },
      // Synchronously creates an InputStream given a path to a file
      // on disk and the encoding of the bytes in that file (defaults to
      // 'utf8' if encoding is null).
      fromPathSync: function fromPathSync(path, encoding) {
        var data = fs.readFileSync(path, encoding);
        return new InputStream(data, true);
      }
    };
    exports.CharStreams = CharStreams;
    /***/
  },

  /***/
  "./node_modules/antlr4/CommonTokenFactory.js":
  /*!***************************************************!*\
    !*** ./node_modules/antlr4/CommonTokenFactory.js ***!
    \***************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_CommonTokenFactoryJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    //
    // This default implementation of {@link TokenFactory} creates
    // {@link CommonToken} objects.
    //
    var CommonToken = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").CommonToken;

    function TokenFactory() {
      return this;
    }

    function CommonTokenFactory(copyText) {
      TokenFactory.call(this); // Indicates whether {@link CommonToken//setText} should be called after
      // constructing tokens to explicitly set the text. This is useful for cases
      // where the input stream might not be able to provide arbitrary substrings
      // of text from the input after the lexer creates a token (e.g. the
      // implementation of {@link CharStream//getText} in
      // {@link UnbufferedCharStream} throws an
      // {@link UnsupportedOperationException}). Explicitly setting the token text
      // allows {@link Token//getText} to be called at any time regardless of the
      // input stream implementation.
      //
      // <p>
      // The default value is {@code false} to avoid the performance and memory
      // overhead of copying text for every token unless explicitly requested.</p>
      //

      this.copyText = copyText === undefined ? false : copyText;
      return this;
    }

    CommonTokenFactory.prototype = Object.create(TokenFactory.prototype);
    CommonTokenFactory.prototype.constructor = CommonTokenFactory; //
    // The default {@link CommonTokenFactory} instance.
    //
    // <p>
    // This token factory does not explicitly copy token text when constructing
    // tokens.</p>
    //

    CommonTokenFactory.DEFAULT = new CommonTokenFactory();

    CommonTokenFactory.prototype.create = function (source, type, text, channel, start, stop, line, column) {
      var t = new CommonToken(source, type, channel, start, stop);
      t.line = line;
      t.column = column;

      if (text !== null) {
        t.text = text;
      } else if (this.copyText && source[1] !== null) {
        t.text = source[1].getText(start, stop);
      }

      return t;
    };

    CommonTokenFactory.prototype.createThin = function (type, text) {
      var t = new CommonToken(null, type);
      t.text = text;
      return t;
    };

    exports.CommonTokenFactory = CommonTokenFactory;
    /***/
  },

  /***/
  "./node_modules/antlr4/CommonTokenStream.js":
  /*!**************************************************!*\
    !*** ./node_modules/antlr4/CommonTokenStream.js ***!
    \**************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_CommonTokenStreamJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    //
    // This class extends {@link BufferedTokenStream} with functionality to filter
    // token streams to tokens on a particular channel (tokens where
    // {@link Token//getChannel} returns a particular value).
    //
    // <p>
    // This token stream provides access to all tokens by index or when calling
    // methods like {@link //getText}. The channel filtering is only used for code
    // accessing tokens via the lookahead methods {@link //LA}, {@link //LT}, and
    // {@link //LB}.</p>
    //
    // <p>
    // By default, tokens are placed on the default channel
    // ({@link Token//DEFAULT_CHANNEL}), but may be reassigned by using the
    // {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to
    // call {@link Lexer//setChannel}.
    // </p>
    //
    // <p>
    // Note: lexer rules which use the {@code ->skip} lexer command or call
    // {@link Lexer//skip} do not produce tokens at all, so input text matched by
    // such a rule will not be available as part of the token stream, regardless of
    // channel.</p>
    ///
    var Token = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").Token;

    var BufferedTokenStream = __webpack_require__(
    /*! ./BufferedTokenStream */
    "./node_modules/antlr4/BufferedTokenStream.js").BufferedTokenStream;

    function CommonTokenStream(lexer, channel) {
      BufferedTokenStream.call(this, lexer);
      this.channel = channel === undefined ? Token.DEFAULT_CHANNEL : channel;
      return this;
    }

    CommonTokenStream.prototype = Object.create(BufferedTokenStream.prototype);
    CommonTokenStream.prototype.constructor = CommonTokenStream;

    CommonTokenStream.prototype.adjustSeekIndex = function (i) {
      return this.nextTokenOnChannel(i, this.channel);
    };

    CommonTokenStream.prototype.LB = function (k) {
      if (k === 0 || this.index - k < 0) {
        return null;
      }

      var i = this.index;
      var n = 1; // find k good tokens looking backwards

      while (n <= k) {
        // skip off-channel tokens
        i = this.previousTokenOnChannel(i - 1, this.channel);
        n += 1;
      }

      if (i < 0) {
        return null;
      }

      return this.tokens[i];
    };

    CommonTokenStream.prototype.LT = function (k) {
      this.lazyInit();

      if (k === 0) {
        return null;
      }

      if (k < 0) {
        return this.LB(-k);
      }

      var i = this.index;
      var n = 1; // we know tokens[pos] is a good one
      // find k good tokens

      while (n < k) {
        // skip off-channel tokens, but make sure to not look past EOF
        if (this.sync(i + 1)) {
          i = this.nextTokenOnChannel(i + 1, this.channel);
        }

        n += 1;
      }

      return this.tokens[i];
    }; // Count EOF just once.///


    CommonTokenStream.prototype.getNumberOfOnChannelTokens = function () {
      var n = 0;
      this.fill();

      for (var i = 0; i < this.tokens.length; i++) {
        var t = this.tokens[i];

        if (t.channel === this.channel) {
          n += 1;
        }

        if (t.type === Token.EOF) {
          break;
        }
      }

      return n;
    };

    exports.CommonTokenStream = CommonTokenStream;
    /***/
  },

  /***/
  "./node_modules/antlr4/FileStream.js":
  /*!*******************************************!*\
    !*** ./node_modules/antlr4/FileStream.js ***!
    \*******************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_FileStreamJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    //
    //  This is an InputStream that is loaded from a file all at once
    //  when you construct the object.
    //
    var InputStream = __webpack_require__(
    /*! ./InputStream */
    "./node_modules/antlr4/InputStream.js").InputStream;

    var isNodeJs = typeof window === 'undefined' && typeof importScripts === 'undefined';
    var fs = isNodeJs ? __webpack_require__(
    /*! fs */
    8) : null;

    function FileStream(fileName, decodeToUnicodeCodePoints) {
      var data = fs.readFileSync(fileName, "utf8");
      InputStream.call(this, data, decodeToUnicodeCodePoints);
      this.fileName = fileName;
      return this;
    }

    FileStream.prototype = Object.create(InputStream.prototype);
    FileStream.prototype.constructor = FileStream;
    exports.FileStream = FileStream;
    /***/
  },

  /***/
  "./node_modules/antlr4/InputStream.js":
  /*!********************************************!*\
    !*** ./node_modules/antlr4/InputStream.js ***!
    \********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_InputStreamJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    var Token = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").Token;

    __webpack_require__(
    /*! ./polyfills/codepointat */
    "./node_modules/antlr4/polyfills/codepointat.js");

    __webpack_require__(
    /*! ./polyfills/fromcodepoint */
    "./node_modules/antlr4/polyfills/fromcodepoint.js"); // Vacuum all input from a string and then treat it like a buffer.


    function _loadString(stream, decodeToUnicodeCodePoints) {
      stream._index = 0;
      stream.data = [];

      if (stream.decodeToUnicodeCodePoints) {
        for (var i = 0; i < stream.strdata.length;) {
          var codePoint = stream.strdata.codePointAt(i);
          stream.data.push(codePoint);
          i += codePoint <= 0xFFFF ? 1 : 2;
        }
      } else {
        for (var i = 0; i < stream.strdata.length; i++) {
          var codeUnit = stream.strdata.charCodeAt(i);
          stream.data.push(codeUnit);
        }
      }

      stream._size = stream.data.length;
    } // If decodeToUnicodeCodePoints is true, the input is treated
    // as a series of Unicode code points.
    //
    // Otherwise, the input is treated as a series of 16-bit UTF-16 code
    // units.


    function InputStream(data, decodeToUnicodeCodePoints) {
      this.name = "<empty>";
      this.strdata = data;
      this.decodeToUnicodeCodePoints = decodeToUnicodeCodePoints || false;

      _loadString(this);

      return this;
    }

    Object.defineProperty(InputStream.prototype, "index", {
      get: function get() {
        return this._index;
      }
    });
    Object.defineProperty(InputStream.prototype, "size", {
      get: function get() {
        return this._size;
      }
    }); // Reset the stream so that it's in the same state it was
    // when the object was created *except* the data array is not
    // touched.
    //

    InputStream.prototype.reset = function () {
      this._index = 0;
    };

    InputStream.prototype.consume = function () {
      if (this._index >= this._size) {
        // assert this.LA(1) == Token.EOF
        throw "cannot consume EOF";
      }

      this._index += 1;
    };

    InputStream.prototype.LA = function (offset) {
      if (offset === 0) {
        return 0; // undefined
      }

      if (offset < 0) {
        offset += 1; // e.g., translate LA(-1) to use offset=0
      }

      var pos = this._index + offset - 1;

      if (pos < 0 || pos >= this._size) {
        // invalid
        return Token.EOF;
      }

      return this.data[pos];
    };

    InputStream.prototype.LT = function (offset) {
      return this.LA(offset);
    }; // mark/release do nothing; we have entire buffer


    InputStream.prototype.mark = function () {
      return -1;
    };

    InputStream.prototype.release = function (marker) {}; // consume() ahead until p==_index; can't just set p=_index as we must
    // update line and column. If we seek backwards, just set p
    //


    InputStream.prototype.seek = function (_index) {
      if (_index <= this._index) {
        this._index = _index; // just jump; don't update stream state (line,
        // ...)

        return;
      } // seek forward


      this._index = Math.min(_index, this._size);
    };

    InputStream.prototype.getText = function (start, stop) {
      if (stop >= this._size) {
        stop = this._size - 1;
      }

      if (start >= this._size) {
        return "";
      } else {
        if (this.decodeToUnicodeCodePoints) {
          var result = "";

          for (var i = start; i <= stop; i++) {
            result += String.fromCodePoint(this.data[i]);
          }

          return result;
        } else {
          return this.strdata.slice(start, stop + 1);
        }
      }
    };

    InputStream.prototype.toString = function () {
      return this.strdata;
    };

    exports.InputStream = InputStream;
    /***/
  },

  /***/
  "./node_modules/antlr4/IntervalSet.js":
  /*!********************************************!*\
    !*** ./node_modules/antlr4/IntervalSet.js ***!
    \********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_IntervalSetJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */

    /*jslint smarttabs:true */
    var Token = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").Token;
    /* stop is not included! */


    function Interval(start, stop) {
      this.start = start;
      this.stop = stop;
      return this;
    }

    Interval.prototype.contains = function (item) {
      return item >= this.start && item < this.stop;
    };

    Interval.prototype.toString = function () {
      if (this.start === this.stop - 1) {
        return this.start.toString();
      } else {
        return this.start.toString() + ".." + (this.stop - 1).toString();
      }
    };

    Object.defineProperty(Interval.prototype, "length", {
      get: function get() {
        return this.stop - this.start;
      }
    });

    function IntervalSet() {
      this.intervals = null;
      this.readOnly = false;
    }

    IntervalSet.prototype.first = function (v) {
      if (this.intervals === null || this.intervals.length === 0) {
        return Token.INVALID_TYPE;
      } else {
        return this.intervals[0].start;
      }
    };

    IntervalSet.prototype.addOne = function (v) {
      this.addInterval(new Interval(v, v + 1));
    };

    IntervalSet.prototype.addRange = function (l, h) {
      this.addInterval(new Interval(l, h + 1));
    };

    IntervalSet.prototype.addInterval = function (v) {
      if (this.intervals === null) {
        this.intervals = [];
        this.intervals.push(v);
      } else {
        // find insert pos
        for (var k = 0; k < this.intervals.length; k++) {
          var i = this.intervals[k]; // distinct range -> insert

          if (v.stop < i.start) {
            this.intervals.splice(k, 0, v);
            return;
          } // contiguous range -> adjust
          else if (v.stop === i.start) {
            this.intervals[k].start = v.start;
            return;
          } // overlapping range -> adjust and reduce
          else if (v.start <= i.stop) {
            this.intervals[k] = new Interval(Math.min(i.start, v.start), Math.max(i.stop, v.stop));
            this.reduce(k);
            return;
          }
        } // greater than any existing


        this.intervals.push(v);
      }
    };

    IntervalSet.prototype.addSet = function (other) {
      if (other.intervals !== null) {
        for (var k = 0; k < other.intervals.length; k++) {
          var i = other.intervals[k];
          this.addInterval(new Interval(i.start, i.stop));
        }
      }

      return this;
    };

    IntervalSet.prototype.reduce = function (k) {
      // only need to reduce if k is not the last
      if (k < this.intervalslength - 1) {
        var l = this.intervals[k];
        var r = this.intervals[k + 1]; // if r contained in l

        if (l.stop >= r.stop) {
          this.intervals.pop(k + 1);
          this.reduce(k);
        } else if (l.stop >= r.start) {
          this.intervals[k] = new Interval(l.start, r.stop);
          this.intervals.pop(k + 1);
        }
      }
    };

    IntervalSet.prototype.complement = function (start, stop) {
      var result = new IntervalSet();
      result.addInterval(new Interval(start, stop + 1));

      for (var i = 0; i < this.intervals.length; i++) {
        result.removeRange(this.intervals[i]);
      }

      return result;
    };

    IntervalSet.prototype.contains = function (item) {
      if (this.intervals === null) {
        return false;
      } else {
        for (var k = 0; k < this.intervals.length; k++) {
          if (this.intervals[k].contains(item)) {
            return true;
          }
        }

        return false;
      }
    };

    Object.defineProperty(IntervalSet.prototype, "length", {
      get: function get() {
        var len = 0;
        this.intervals.map(function (i) {
          len += i.length;
        });
        return len;
      }
    });

    IntervalSet.prototype.removeRange = function (v) {
      if (v.start === v.stop - 1) {
        this.removeOne(v.start);
      } else if (this.intervals !== null) {
        var k = 0;

        for (var n = 0; n < this.intervals.length; n++) {
          var i = this.intervals[k]; // intervals are ordered

          if (v.stop <= i.start) {
            return;
          } // check for including range, split it
          else if (v.start > i.start && v.stop < i.stop) {
            this.intervals[k] = new Interval(i.start, v.start);
            var x = new Interval(v.stop, i.stop);
            this.intervals.splice(k, 0, x);
            return;
          } // check for included range, remove it
          else if (v.start <= i.start && v.stop >= i.stop) {
            this.intervals.splice(k, 1);
            k = k - 1; // need another pass
          } // check for lower boundary
          else if (v.start < i.stop) {
            this.intervals[k] = new Interval(i.start, v.start);
          } // check for upper boundary
          else if (v.stop < i.stop) {
            this.intervals[k] = new Interval(v.stop, i.stop);
          }

          k += 1;
        }
      }
    };

    IntervalSet.prototype.removeOne = function (v) {
      if (this.intervals !== null) {
        for (var k = 0; k < this.intervals.length; k++) {
          var i = this.intervals[k]; // intervals is ordered

          if (v < i.start) {
            return;
          } // check for single value range
          else if (v === i.start && v === i.stop - 1) {
            this.intervals.splice(k, 1);
            return;
          } // check for lower boundary
          else if (v === i.start) {
            this.intervals[k] = new Interval(i.start + 1, i.stop);
            return;
          } // check for upper boundary
          else if (v === i.stop - 1) {
            this.intervals[k] = new Interval(i.start, i.stop - 1);
            return;
          } // split existing range
          else if (v < i.stop - 1) {
            var x = new Interval(i.start, v);
            i.start = v + 1;
            this.intervals.splice(k, 0, x);
            return;
          }
        }
      }
    };

    IntervalSet.prototype.toString = function (literalNames, symbolicNames, elemsAreChar) {
      literalNames = literalNames || null;
      symbolicNames = symbolicNames || null;
      elemsAreChar = elemsAreChar || false;

      if (this.intervals === null) {
        return "{}";
      } else if (literalNames !== null || symbolicNames !== null) {
        return this.toTokenString(literalNames, symbolicNames);
      } else if (elemsAreChar) {
        return this.toCharString();
      } else {
        return this.toIndexString();
      }
    };

    IntervalSet.prototype.toCharString = function () {
      var names = [];

      for (var i = 0; i < this.intervals.length; i++) {
        var v = this.intervals[i];

        if (v.stop === v.start + 1) {
          if (v.start === Token.EOF) {
            names.push("<EOF>");
          } else {
            names.push("'" + String.fromCharCode(v.start) + "'");
          }
        } else {
          names.push("'" + String.fromCharCode(v.start) + "'..'" + String.fromCharCode(v.stop - 1) + "'");
        }
      }

      if (names.length > 1) {
        return "{" + names.join(", ") + "}";
      } else {
        return names[0];
      }
    };

    IntervalSet.prototype.toIndexString = function () {
      var names = [];

      for (var i = 0; i < this.intervals.length; i++) {
        var v = this.intervals[i];

        if (v.stop === v.start + 1) {
          if (v.start === Token.EOF) {
            names.push("<EOF>");
          } else {
            names.push(v.start.toString());
          }
        } else {
          names.push(v.start.toString() + ".." + (v.stop - 1).toString());
        }
      }

      if (names.length > 1) {
        return "{" + names.join(", ") + "}";
      } else {
        return names[0];
      }
    };

    IntervalSet.prototype.toTokenString = function (literalNames, symbolicNames) {
      var names = [];

      for (var i = 0; i < this.intervals.length; i++) {
        var v = this.intervals[i];

        for (var j = v.start; j < v.stop; j++) {
          names.push(this.elementName(literalNames, symbolicNames, j));
        }
      }

      if (names.length > 1) {
        return "{" + names.join(", ") + "}";
      } else {
        return names[0];
      }
    };

    IntervalSet.prototype.elementName = function (literalNames, symbolicNames, a) {
      if (a === Token.EOF) {
        return "<EOF>";
      } else if (a === Token.EPSILON) {
        return "<EPSILON>";
      } else {
        return literalNames[a] || symbolicNames[a];
      }
    };

    exports.Interval = Interval;
    exports.IntervalSet = IntervalSet;
    /***/
  },

  /***/
  "./node_modules/antlr4/LL1Analyzer.js":
  /*!********************************************!*\
    !*** ./node_modules/antlr4/LL1Analyzer.js ***!
    \********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_LL1AnalyzerJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    var Set = __webpack_require__(
    /*! ./Utils */
    "./node_modules/antlr4/Utils.js").Set;

    var BitSet = __webpack_require__(
    /*! ./Utils */
    "./node_modules/antlr4/Utils.js").BitSet;

    var Token = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").Token;

    var ATNConfig = __webpack_require__(
    /*! ./atn/ATNConfig */
    "./node_modules/antlr4/atn/ATNConfig.js").ATNConfig;

    var Interval = __webpack_require__(
    /*! ./IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval;

    var IntervalSet = __webpack_require__(
    /*! ./IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").IntervalSet;

    var RuleStopState = __webpack_require__(
    /*! ./atn/ATNState */
    "./node_modules/antlr4/atn/ATNState.js").RuleStopState;

    var RuleTransition = __webpack_require__(
    /*! ./atn/Transition */
    "./node_modules/antlr4/atn/Transition.js").RuleTransition;

    var NotSetTransition = __webpack_require__(
    /*! ./atn/Transition */
    "./node_modules/antlr4/atn/Transition.js").NotSetTransition;

    var WildcardTransition = __webpack_require__(
    /*! ./atn/Transition */
    "./node_modules/antlr4/atn/Transition.js").WildcardTransition;

    var AbstractPredicateTransition = __webpack_require__(
    /*! ./atn/Transition */
    "./node_modules/antlr4/atn/Transition.js").AbstractPredicateTransition;

    var pc = __webpack_require__(
    /*! ./PredictionContext */
    "./node_modules/antlr4/PredictionContext.js");

    var predictionContextFromRuleContext = pc.predictionContextFromRuleContext;
    var PredictionContext = pc.PredictionContext;
    var SingletonPredictionContext = pc.SingletonPredictionContext;

    function LL1Analyzer(atn) {
      this.atn = atn;
    } //* Special value added to the lookahead sets to indicate that we hit
    //  a predicate during analysis if {@code seeThruPreds==false}.
    ///


    LL1Analyzer.HIT_PRED = Token.INVALID_TYPE; //*
    // Calculates the SLL(1) expected lookahead set for each outgoing transition
    // of an {@link ATNState}. The returned array has one element for each
    // outgoing transition in {@code s}. If the closure from transition
    // <em>i</em> leads to a semantic predicate before matching a symbol, the
    // element at index <em>i</em> of the result will be {@code null}.
    //
    // @param s the ATN state
    // @return the expected symbols for each outgoing transition of {@code s}.
    ///

    LL1Analyzer.prototype.getDecisionLookahead = function (s) {
      if (s === null) {
        return null;
      }

      var count = s.transitions.length;
      var look = [];

      for (var alt = 0; alt < count; alt++) {
        look[alt] = new IntervalSet();
        var lookBusy = new Set();
        var seeThruPreds = false; // fail to get lookahead upon pred

        this._LOOK(s.transition(alt).target, null, PredictionContext.EMPTY, look[alt], lookBusy, new BitSet(), seeThruPreds, false); // Wipe out lookahead for this alternative if we found nothing
        // or we had a predicate when we !seeThruPreds


        if (look[alt].length === 0 || look[alt].contains(LL1Analyzer.HIT_PRED)) {
          look[alt] = null;
        }
      }

      return look;
    }; //*
    // Compute set of tokens that can follow {@code s} in the ATN in the
    // specified {@code ctx}.
    //
    // <p>If {@code ctx} is {@code null} and the end of the rule containing
    // {@code s} is reached, {@link Token//EPSILON} is added to the result set.
    // If {@code ctx} is not {@code null} and the end of the outermost rule is
    // reached, {@link Token//EOF} is added to the result set.</p>
    //
    // @param s the ATN state
    // @param stopState the ATN state to stop at. This can be a
    // {@link BlockEndState} to detect epsilon paths through a closure.
    // @param ctx the complete parser context, or {@code null} if the context
    // should be ignored
    //
    // @return The set of tokens that can follow {@code s} in the ATN in the
    // specified {@code ctx}.
    ///


    LL1Analyzer.prototype.LOOK = function (s, stopState, ctx) {
      var r = new IntervalSet();
      var seeThruPreds = true; // ignore preds; get all lookahead

      ctx = ctx || null;
      var lookContext = ctx !== null ? predictionContextFromRuleContext(s.atn, ctx) : null;

      this._LOOK(s, stopState, lookContext, r, new Set(), new BitSet(), seeThruPreds, true);

      return r;
    }; //*
    // Compute set of tokens that can follow {@code s} in the ATN in the
    // specified {@code ctx}.
    //
    // <p>If {@code ctx} is {@code null} and {@code stopState} or the end of the
    // rule containing {@code s} is reached, {@link Token//EPSILON} is added to
    // the result set. If {@code ctx} is not {@code null} and {@code addEOF} is
    // {@code true} and {@code stopState} or the end of the outermost rule is
    // reached, {@link Token//EOF} is added to the result set.</p>
    //
    // @param s the ATN state.
    // @param stopState the ATN state to stop at. This can be a
    // {@link BlockEndState} to detect epsilon paths through a closure.
    // @param ctx The outer context, or {@code null} if the outer context should
    // not be used.
    // @param look The result lookahead set.
    // @param lookBusy A set used for preventing epsilon closures in the ATN
    // from causing a stack overflow. Outside code should pass
    // {@code new Set<ATNConfig>} for this argument.
    // @param calledRuleStack A set used for preventing left recursion in the
    // ATN from causing a stack overflow. Outside code should pass
    // {@code new BitSet()} for this argument.
    // @param seeThruPreds {@code true} to true semantic predicates as
    // implicitly {@code true} and "see through them", otherwise {@code false}
    // to treat semantic predicates as opaque and add {@link //HIT_PRED} to the
    // result if one is encountered.
    // @param addEOF Add {@link Token//EOF} to the result if the end of the
    // outermost context is reached. This parameter has no effect if {@code ctx}
    // is {@code null}.
    ///


    LL1Analyzer.prototype._LOOK = function (s, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) {
      var c = new ATNConfig({
        state: s,
        alt: 0,
        context: ctx
      }, null);

      if (lookBusy.contains(c)) {
        return;
      }

      lookBusy.add(c);

      if (s === stopState) {
        if (ctx === null) {
          look.addOne(Token.EPSILON);
          return;
        } else if (ctx.isEmpty() && addEOF) {
          look.addOne(Token.EOF);
          return;
        }
      }

      if (s instanceof RuleStopState) {
        if (ctx === null) {
          look.addOne(Token.EPSILON);
          return;
        } else if (ctx.isEmpty() && addEOF) {
          look.addOne(Token.EOF);
          return;
        }

        if (ctx !== PredictionContext.EMPTY) {
          // run thru all possible stack tops in ctx
          for (var i = 0; i < ctx.length; i++) {
            var returnState = this.atn.states[ctx.getReturnState(i)];
            var removed = calledRuleStack.contains(returnState.ruleIndex);

            try {
              calledRuleStack.remove(returnState.ruleIndex);

              this._LOOK(returnState, stopState, ctx.getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
            } finally {
              if (removed) {
                calledRuleStack.add(returnState.ruleIndex);
              }
            }
          }

          return;
        }
      }

      for (var j = 0; j < s.transitions.length; j++) {
        var t = s.transitions[j];

        if (t.constructor === RuleTransition) {
          if (calledRuleStack.contains(t.target.ruleIndex)) {
            continue;
          }

          var newContext = SingletonPredictionContext.create(ctx, t.followState.stateNumber);

          try {
            calledRuleStack.add(t.target.ruleIndex);

            this._LOOK(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
          } finally {
            calledRuleStack.remove(t.target.ruleIndex);
          }
        } else if (t instanceof AbstractPredicateTransition) {
          if (seeThruPreds) {
            this._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
          } else {
            look.addOne(LL1Analyzer.HIT_PRED);
          }
        } else if (t.isEpsilon) {
          this._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
        } else if (t.constructor === WildcardTransition) {
          look.addRange(Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);
        } else {
          var set = t.label;

          if (set !== null) {
            if (t instanceof NotSetTransition) {
              set = set.complement(Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);
            }

            look.addSet(set);
          }
        }
      }
    };

    exports.LL1Analyzer = LL1Analyzer;
    /***/
  },

  /***/
  "./node_modules/antlr4/Lexer.js":
  /*!**************************************!*\
    !*** ./node_modules/antlr4/Lexer.js ***!
    \**************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_LexerJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    // A lexer is recognizer that draws input symbols from a character stream.
    //  lexer grammars result in a subclass of this object. A Lexer object
    //  uses simplified match() and error recovery mechanisms in the interest of speed.
    var Token = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").Token;

    var Recognizer = __webpack_require__(
    /*! ./Recognizer */
    "./node_modules/antlr4/Recognizer.js").Recognizer;

    var CommonTokenFactory = __webpack_require__(
    /*! ./CommonTokenFactory */
    "./node_modules/antlr4/CommonTokenFactory.js").CommonTokenFactory;

    var RecognitionException = __webpack_require__(
    /*! ./error/Errors */
    "./node_modules/antlr4/error/Errors.js").RecognitionException;

    var LexerNoViableAltException = __webpack_require__(
    /*! ./error/Errors */
    "./node_modules/antlr4/error/Errors.js").LexerNoViableAltException;

    function TokenSource() {
      return this;
    }

    function Lexer(input) {
      Recognizer.call(this);
      this._input = input;
      this._factory = CommonTokenFactory.DEFAULT;
      this._tokenFactorySourcePair = [this, input];
      this._interp = null; // child classes must populate this
      // The goal of all lexer rules/methods is to create a token object.
      // this is an instance variable as multiple rules may collaborate to
      // create a single token. nextToken will return this object after
      // matching lexer rule(s). If you subclass to allow multiple token
      // emissions, then set this to the last token to be matched or
      // something nonnull so that the auto token emit mechanism will not
      // emit another token.

      this._token = null; // What character index in the stream did the current token start at?
      // Needed, for example, to get the text for current token. Set at
      // the start of nextToken.

      this._tokenStartCharIndex = -1; // The line on which the first character of the token resides///

      this._tokenStartLine = -1; // The character position of first character within the line///

      this._tokenStartColumn = -1; // Once we see EOF on char stream, next token will be EOF.
      // If you have DONE : EOF ; then you see DONE EOF.

      this._hitEOF = false; // The channel number for the current token///

      this._channel = Token.DEFAULT_CHANNEL; // The token type for the current token///

      this._type = Token.INVALID_TYPE;
      this._modeStack = [];
      this._mode = Lexer.DEFAULT_MODE; // You can set the text for the current token to override what is in
      // the input char buffer. Use setText() or can set this instance var.
      // /

      this._text = null;
      return this;
    }

    Lexer.prototype = Object.create(Recognizer.prototype);
    Lexer.prototype.constructor = Lexer;
    Lexer.DEFAULT_MODE = 0;
    Lexer.MORE = -2;
    Lexer.SKIP = -3;
    Lexer.DEFAULT_TOKEN_CHANNEL = Token.DEFAULT_CHANNEL;
    Lexer.HIDDEN = Token.HIDDEN_CHANNEL;
    Lexer.MIN_CHAR_VALUE = 0x0000;
    Lexer.MAX_CHAR_VALUE = 0x10FFFF;

    Lexer.prototype.reset = function () {
      // wack Lexer state variables
      if (this._input !== null) {
        this._input.seek(0); // rewind the input

      }

      this._token = null;
      this._type = Token.INVALID_TYPE;
      this._channel = Token.DEFAULT_CHANNEL;
      this._tokenStartCharIndex = -1;
      this._tokenStartColumn = -1;
      this._tokenStartLine = -1;
      this._text = null;
      this._hitEOF = false;
      this._mode = Lexer.DEFAULT_MODE;
      this._modeStack = [];

      this._interp.reset();
    }; // Return a token from this source; i.e., match a token on the char stream.


    Lexer.prototype.nextToken = function () {
      if (this._input === null) {
        throw "nextToken requires a non-null input stream.";
      } // Mark start location in char stream so unbuffered streams are
      // guaranteed at least have text of current token


      var tokenStartMarker = this._input.mark();

      try {
        while (true) {
          if (this._hitEOF) {
            this.emitEOF();
            return this._token;
          }

          this._token = null;
          this._channel = Token.DEFAULT_CHANNEL;
          this._tokenStartCharIndex = this._input.index;
          this._tokenStartColumn = this._interp.column;
          this._tokenStartLine = this._interp.line;
          this._text = null;
          var continueOuter = false;

          while (true) {
            this._type = Token.INVALID_TYPE;
            var ttype = Lexer.SKIP;

            try {
              ttype = this._interp.match(this._input, this._mode);
            } catch (e) {
              if (e instanceof RecognitionException) {
                this.notifyListeners(e); // report error

                this.recover(e);
              } else {
                console.log(e.stack);
                throw e;
              }
            }

            if (this._input.LA(1) === Token.EOF) {
              this._hitEOF = true;
            }

            if (this._type === Token.INVALID_TYPE) {
              this._type = ttype;
            }

            if (this._type === Lexer.SKIP) {
              continueOuter = true;
              break;
            }

            if (this._type !== Lexer.MORE) {
              break;
            }
          }

          if (continueOuter) {
            continue;
          }

          if (this._token === null) {
            this.emit();
          }

          return this._token;
        }
      } finally {
        // make sure we release marker after match or
        // unbuffered char stream will keep buffering
        this._input.release(tokenStartMarker);
      }
    }; // Instruct the lexer to skip creating a token for current lexer rule
    // and look for another token. nextToken() knows to keep looking when
    // a lexer rule finishes with token set to SKIP_TOKEN. Recall that
    // if token==null at end of any token rule, it creates one for you
    // and emits it.
    // /


    Lexer.prototype.skip = function () {
      this._type = Lexer.SKIP;
    };

    Lexer.prototype.more = function () {
      this._type = Lexer.MORE;
    };

    Lexer.prototype.mode = function (m) {
      this._mode = m;
    };

    Lexer.prototype.pushMode = function (m) {
      if (this._interp.debug) {
        console.log("pushMode " + m);
      }

      this._modeStack.push(this._mode);

      this.mode(m);
    };

    Lexer.prototype.popMode = function () {
      if (this._modeStack.length === 0) {
        throw "Empty Stack";
      }

      if (this._interp.debug) {
        console.log("popMode back to " + this._modeStack.slice(0, -1));
      }

      this.mode(this._modeStack.pop());
      return this._mode;
    }; // Set the char stream and reset the lexer


    Object.defineProperty(Lexer.prototype, "inputStream", {
      get: function get() {
        return this._input;
      },
      set: function set(input) {
        this._input = null;
        this._tokenFactorySourcePair = [this, this._input];
        this.reset();
        this._input = input;
        this._tokenFactorySourcePair = [this, this._input];
      }
    });
    Object.defineProperty(Lexer.prototype, "sourceName", {
      get: function sourceName() {
        return this._input.sourceName;
      }
    }); // By default does not support multiple emits per nextToken invocation
    // for efficiency reasons. Subclass and override this method, nextToken,
    // and getToken (to push tokens into a list and pull from that list
    // rather than a single variable as this implementation does).
    // /

    Lexer.prototype.emitToken = function (token) {
      this._token = token;
    }; // The standard method called to automatically emit a token at the
    // outermost lexical rule. The token object should point into the
    // char buffer start..stop. If there is a text override in 'text',
    // use that to set the token's text. Override this method to emit
    // custom Token objects or provide a new factory.
    // /


    Lexer.prototype.emit = function () {
      var t = this._factory.create(this._tokenFactorySourcePair, this._type, this._text, this._channel, this._tokenStartCharIndex, this.getCharIndex() - 1, this._tokenStartLine, this._tokenStartColumn);

      this.emitToken(t);
      return t;
    };

    Lexer.prototype.emitEOF = function () {
      var cpos = this.column;
      var lpos = this.line;

      var eof = this._factory.create(this._tokenFactorySourcePair, Token.EOF, null, Token.DEFAULT_CHANNEL, this._input.index, this._input.index - 1, lpos, cpos);

      this.emitToken(eof);
      return eof;
    };

    Object.defineProperty(Lexer.prototype, "type", {
      get: function get() {
        return this.type;
      },
      set: function set(type) {
        this._type = type;
      }
    });
    Object.defineProperty(Lexer.prototype, "line", {
      get: function get() {
        return this._interp.line;
      },
      set: function set(line) {
        this._interp.line = line;
      }
    });
    Object.defineProperty(Lexer.prototype, "column", {
      get: function get() {
        return this._interp.column;
      },
      set: function set(column) {
        this._interp.column = column;
      }
    }); // What is the index of the current character of lookahead?///

    Lexer.prototype.getCharIndex = function () {
      return this._input.index;
    }; // Return the text matched so far for the current token or any text override.
    //Set the complete text of this token; it wipes any previous changes to the text.


    Object.defineProperty(Lexer.prototype, "text", {
      get: function get() {
        if (this._text !== null) {
          return this._text;
        } else {
          return this._interp.getText(this._input);
        }
      },
      set: function set(text) {
        this._text = text;
      }
    }); // Return a list of all Token objects in input char stream.
    // Forces load of all tokens. Does not include EOF token.
    // /

    Lexer.prototype.getAllTokens = function () {
      var tokens = [];
      var t = this.nextToken();

      while (t.type !== Token.EOF) {
        tokens.push(t);
        t = this.nextToken();
      }

      return tokens;
    };

    Lexer.prototype.notifyListeners = function (e) {
      var start = this._tokenStartCharIndex;
      var stop = this._input.index;

      var text = this._input.getText(start, stop);

      var msg = "token recognition error at: '" + this.getErrorDisplay(text) + "'";
      var listener = this.getErrorListenerDispatch();
      listener.syntaxError(this, null, this._tokenStartLine, this._tokenStartColumn, msg, e);
    };

    Lexer.prototype.getErrorDisplay = function (s) {
      var d = [];

      for (var i = 0; i < s.length; i++) {
        d.push(s[i]);
      }

      return d.join('');
    };

    Lexer.prototype.getErrorDisplayForChar = function (c) {
      if (c.charCodeAt(0) === Token.EOF) {
        return "<EOF>";
      } else if (c === '\n') {
        return "\\n";
      } else if (c === '\t') {
        return "\\t";
      } else if (c === '\r') {
        return "\\r";
      } else {
        return c;
      }
    };

    Lexer.prototype.getCharErrorDisplay = function (c) {
      return "'" + this.getErrorDisplayForChar(c) + "'";
    }; // Lexers can normally match any char in it's vocabulary after matching
    // a token, so do the easy thing and just kill a character and hope
    // it all works out. You can instead use the rule invocation stack
    // to do sophisticated error recovery if you are in a fragment rule.
    // /


    Lexer.prototype.recover = function (re) {
      if (this._input.LA(1) !== Token.EOF) {
        if (re instanceof LexerNoViableAltException) {
          // skip a char and try again
          this._interp.consume(this._input);
        } else {
          // TODO: Do we lose character or line position information?
          this._input.consume();
        }
      }
    };

    exports.Lexer = Lexer;
    /***/
  },

  /***/
  "./node_modules/antlr4/Parser.js":
  /*!***************************************!*\
    !*** ./node_modules/antlr4/Parser.js ***!
    \***************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_ParserJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    var Token = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").Token;

    var ParseTreeListener = __webpack_require__(
    /*! ./tree/Tree */
    "./node_modules/antlr4/tree/Tree.js").ParseTreeListener;

    var Recognizer = __webpack_require__(
    /*! ./Recognizer */
    "./node_modules/antlr4/Recognizer.js").Recognizer;

    var DefaultErrorStrategy = __webpack_require__(
    /*! ./error/ErrorStrategy */
    "./node_modules/antlr4/error/ErrorStrategy.js").DefaultErrorStrategy;

    var ATNDeserializer = __webpack_require__(
    /*! ./atn/ATNDeserializer */
    "./node_modules/antlr4/atn/ATNDeserializer.js").ATNDeserializer;

    var ATNDeserializationOptions = __webpack_require__(
    /*! ./atn/ATNDeserializationOptions */
    "./node_modules/antlr4/atn/ATNDeserializationOptions.js").ATNDeserializationOptions;

    var TerminalNode = __webpack_require__(
    /*! ./tree/Tree */
    "./node_modules/antlr4/tree/Tree.js").TerminalNode;

    var ErrorNode = __webpack_require__(
    /*! ./tree/Tree */
    "./node_modules/antlr4/tree/Tree.js").ErrorNode;

    function TraceListener(parser) {
      ParseTreeListener.call(this);
      this.parser = parser;
      return this;
    }

    TraceListener.prototype = Object.create(ParseTreeListener.prototype);
    TraceListener.prototype.constructor = TraceListener;

    TraceListener.prototype.enterEveryRule = function (ctx) {
      console.log("enter   " + this.parser.ruleNames[ctx.ruleIndex] + ", LT(1)=" + this.parser._input.LT(1).text);
    };

    TraceListener.prototype.visitTerminal = function (node) {
      console.log("consume " + node.symbol + " rule " + this.parser.ruleNames[this.parser._ctx.ruleIndex]);
    };

    TraceListener.prototype.exitEveryRule = function (ctx) {
      console.log("exit    " + this.parser.ruleNames[ctx.ruleIndex] + ", LT(1)=" + this.parser._input.LT(1).text);
    }; // this is all the parsing support code essentially; most of it is error
    // recovery stuff.//


    function Parser(input) {
      Recognizer.call(this); // The input stream.

      this._input = null; // The error handling strategy for the parser. The default value is a new
      // instance of {@link DefaultErrorStrategy}.

      this._errHandler = new DefaultErrorStrategy();
      this._precedenceStack = [];

      this._precedenceStack.push(0); // The {@link ParserRuleContext} object for the currently executing rule.
      // this is always non-null during the parsing process.


      this._ctx = null; // Specifies whether or not the parser should construct a parse tree during
      // the parsing process. The default value is {@code true}.

      this.buildParseTrees = true; // When {@link //setTrace}{@code (true)} is called, a reference to the
      // {@link TraceListener} is stored here so it can be easily removed in a
      // later call to {@link //setTrace}{@code (false)}. The listener itself is
      // implemented as a parser listener so this field is not directly used by
      // other parser methods.

      this._tracer = null; // The list of {@link ParseTreeListener} listeners registered to receive
      // events during the parse.

      this._parseListeners = null; // The number of syntax errors reported during parsing. this value is
      // incremented each time {@link //notifyErrorListeners} is called.

      this._syntaxErrors = 0;
      this.setInputStream(input);
      return this;
    }

    Parser.prototype = Object.create(Recognizer.prototype);
    Parser.prototype.contructor = Parser; // this field maps from the serialized ATN string to the deserialized {@link
    // ATN} with
    // bypass alternatives.
    //
    // @see ATNDeserializationOptions//isGenerateRuleBypassTransitions()
    //

    Parser.bypassAltsAtnCache = {}; // reset the parser's state//

    Parser.prototype.reset = function () {
      if (this._input !== null) {
        this._input.seek(0);
      }

      this._errHandler.reset(this);

      this._ctx = null;
      this._syntaxErrors = 0;
      this.setTrace(false);
      this._precedenceStack = [];

      this._precedenceStack.push(0);

      if (this._interp !== null) {
        this._interp.reset();
      }
    }; // Match current input symbol against {@code ttype}. If the symbol type
    // matches, {@link ANTLRErrorStrategy//reportMatch} and {@link //consume} are
    // called to complete the match process.
    //
    // <p>If the symbol type does not match,
    // {@link ANTLRErrorStrategy//recoverInline} is called on the current error
    // strategy to attempt recovery. If {@link //getBuildParseTree} is
    // {@code true} and the token index of the symbol returned by
    // {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to
    // the parse tree by calling {@link ParserRuleContext//addErrorNode}.</p>
    //
    // @param ttype the token type to match
    // @return the matched symbol
    // @throws RecognitionException if the current input symbol did not match
    // {@code ttype} and the error strategy could not recover from the
    // mismatched symbol


    Parser.prototype.match = function (ttype) {
      var t = this.getCurrentToken();

      if (t.type === ttype) {
        this._errHandler.reportMatch(this);

        this.consume();
      } else {
        t = this._errHandler.recoverInline(this);

        if (this.buildParseTrees && t.tokenIndex === -1) {
          // we must have conjured up a new token during single token
          // insertion
          // if it's not the current symbol
          this._ctx.addErrorNode(t);
        }
      }

      return t;
    }; // Match current input symbol as a wildcard. If the symbol type matches
    // (i.e. has a value greater than 0), {@link ANTLRErrorStrategy//reportMatch}
    // and {@link //consume} are called to complete the match process.
    //
    // <p>If the symbol type does not match,
    // {@link ANTLRErrorStrategy//recoverInline} is called on the current error
    // strategy to attempt recovery. If {@link //getBuildParseTree} is
    // {@code true} and the token index of the symbol returned by
    // {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to
    // the parse tree by calling {@link ParserRuleContext//addErrorNode}.</p>
    //
    // @return the matched symbol
    // @throws RecognitionException if the current input symbol did not match
    // a wildcard and the error strategy could not recover from the mismatched
    // symbol


    Parser.prototype.matchWildcard = function () {
      var t = this.getCurrentToken();

      if (t.type > 0) {
        this._errHandler.reportMatch(this);

        this.consume();
      } else {
        t = this._errHandler.recoverInline(this);

        if (this._buildParseTrees && t.tokenIndex === -1) {
          // we must have conjured up a new token during single token
          // insertion
          // if it's not the current symbol
          this._ctx.addErrorNode(t);
        }
      }

      return t;
    };

    Parser.prototype.getParseListeners = function () {
      return this._parseListeners || [];
    }; // Registers {@code listener} to receive events during the parsing process.
    //
    // <p>To support output-preserving grammar transformations (including but not
    // limited to left-recursion removal, automated left-factoring, and
    // optimized code generation), calls to listener methods during the parse
    // may differ substantially from calls made by
    // {@link ParseTreeWalker//DEFAULT} used after the parse is complete. In
    // particular, rule entry and exit events may occur in a different order
    // during the parse than after the parser. In addition, calls to certain
    // rule entry methods may be omitted.</p>
    //
    // <p>With the following specific exceptions, calls to listener events are
    // <em>deterministic</em>, i.e. for identical input the calls to listener
    // methods will be the same.</p>
    //
    // <ul>
    // <li>Alterations to the grammar used to generate code may change the
    // behavior of the listener calls.</li>
    // <li>Alterations to the command line options passed to ANTLR 4 when
    // generating the parser may change the behavior of the listener calls.</li>
    // <li>Changing the version of the ANTLR Tool used to generate the parser
    // may change the behavior of the listener calls.</li>
    // </ul>
    //
    // @param listener the listener to add
    //
    // @throws NullPointerException if {@code} listener is {@code null}
    //


    Parser.prototype.addParseListener = function (listener) {
      if (listener === null) {
        throw "listener";
      }

      if (this._parseListeners === null) {
        this._parseListeners = [];
      }

      this._parseListeners.push(listener);
    }; //
    // Remove {@code listener} from the list of parse listeners.
    //
    // <p>If {@code listener} is {@code null} or has not been added as a parse
    // listener, this method does nothing.</p>
    // @param listener the listener to remove
    //


    Parser.prototype.removeParseListener = function (listener) {
      if (this._parseListeners !== null) {
        var idx = this._parseListeners.indexOf(listener);

        if (idx >= 0) {
          this._parseListeners.splice(idx, 1);
        }

        if (this._parseListeners.length === 0) {
          this._parseListeners = null;
        }
      }
    }; // Remove all parse listeners.


    Parser.prototype.removeParseListeners = function () {
      this._parseListeners = null;
    }; // Notify any parse listeners of an enter rule event.


    Parser.prototype.triggerEnterRuleEvent = function () {
      if (this._parseListeners !== null) {
        var ctx = this._ctx;

        this._parseListeners.map(function (listener) {
          listener.enterEveryRule(ctx);
          ctx.enterRule(listener);
        });
      }
    }; //
    // Notify any parse listeners of an exit rule event.
    //
    // @see //addParseListener
    //


    Parser.prototype.triggerExitRuleEvent = function () {
      if (this._parseListeners !== null) {
        // reverse order walk of listeners
        var ctx = this._ctx;

        this._parseListeners.slice(0).reverse().map(function (listener) {
          ctx.exitRule(listener);
          listener.exitEveryRule(ctx);
        });
      }
    };

    Parser.prototype.getTokenFactory = function () {
      return this._input.tokenSource._factory;
    }; // Tell our token source and error strategy about a new way to create tokens.//


    Parser.prototype.setTokenFactory = function (factory) {
      this._input.tokenSource._factory = factory;
    }; // The ATN with bypass alternatives is expensive to create so we create it
    // lazily.
    //
    // @throws UnsupportedOperationException if the current parser does not
    // implement the {@link //getSerializedATN()} method.
    //


    Parser.prototype.getATNWithBypassAlts = function () {
      var serializedAtn = this.getSerializedATN();

      if (serializedAtn === null) {
        throw "The current parser does not support an ATN with bypass alternatives.";
      }

      var result = this.bypassAltsAtnCache[serializedAtn];

      if (result === null) {
        var deserializationOptions = new ATNDeserializationOptions();
        deserializationOptions.generateRuleBypassTransitions = true;
        result = new ATNDeserializer(deserializationOptions).deserialize(serializedAtn);
        this.bypassAltsAtnCache[serializedAtn] = result;
      }

      return result;
    }; // The preferred method of getting a tree pattern. For example, here's a
    // sample use:
    //
    // <pre>
    // ParseTree t = parser.expr();
    // ParseTreePattern p = parser.compileParseTreePattern("&lt;ID&gt;+0",
    // MyParser.RULE_expr);
    // ParseTreeMatch m = p.match(t);
    // String id = m.get("ID");
    // </pre>


    var Lexer = __webpack_require__(
    /*! ./Lexer */
    "./node_modules/antlr4/Lexer.js").Lexer;

    Parser.prototype.compileParseTreePattern = function (pattern, patternRuleIndex, lexer) {
      lexer = lexer || null;

      if (lexer === null) {
        if (this.getTokenStream() !== null) {
          var tokenSource = this.getTokenStream().tokenSource;

          if (tokenSource instanceof Lexer) {
            lexer = tokenSource;
          }
        }
      }

      if (lexer === null) {
        throw "Parser can't discover a lexer to use";
      }

      var m = new ParseTreePatternMatcher(lexer, this);
      return m.compile(pattern, patternRuleIndex);
    };

    Parser.prototype.getInputStream = function () {
      return this.getTokenStream();
    };

    Parser.prototype.setInputStream = function (input) {
      this.setTokenStream(input);
    };

    Parser.prototype.getTokenStream = function () {
      return this._input;
    }; // Set the token stream and reset the parser.//


    Parser.prototype.setTokenStream = function (input) {
      this._input = null;
      this.reset();
      this._input = input;
    }; // Match needs to return the current input symbol, which gets put
    // into the label for the associated token ref; e.g., x=ID.
    //


    Parser.prototype.getCurrentToken = function () {
      return this._input.LT(1);
    };

    Parser.prototype.notifyErrorListeners = function (msg, offendingToken, err) {
      offendingToken = offendingToken || null;
      err = err || null;

      if (offendingToken === null) {
        offendingToken = this.getCurrentToken();
      }

      this._syntaxErrors += 1;
      var line = offendingToken.line;
      var column = offendingToken.column;
      var listener = this.getErrorListenerDispatch();
      listener.syntaxError(this, offendingToken, line, column, msg, err);
    }; //
    // Consume and return the {@linkplain //getCurrentToken current symbol}.
    //
    // <p>E.g., given the following input with {@code A} being the current
    // lookahead symbol, this function moves the cursor to {@code B} and returns
    // {@code A}.</p>
    //
    // <pre>
    // A B
    // ^
    // </pre>
    //
    // If the parser is not in error recovery mode, the consumed symbol is added
    // to the parse tree using {@link ParserRuleContext//addChild(Token)}, and
    // {@link ParseTreeListener//visitTerminal} is called on any parse listeners.
    // If the parser <em>is</em> in error recovery mode, the consumed symbol is
    // added to the parse tree using
    // {@link ParserRuleContext//addErrorNode(Token)}, and
    // {@link ParseTreeListener//visitErrorNode} is called on any parse
    // listeners.
    //


    Parser.prototype.consume = function () {
      var o = this.getCurrentToken();

      if (o.type !== Token.EOF) {
        this.getInputStream().consume();
      }

      var hasListener = this._parseListeners !== null && this._parseListeners.length > 0;

      if (this.buildParseTrees || hasListener) {
        var node;

        if (this._errHandler.inErrorRecoveryMode(this)) {
          node = this._ctx.addErrorNode(o);
        } else {
          node = this._ctx.addTokenNode(o);
        }

        node.invokingState = this.state;

        if (hasListener) {
          this._parseListeners.map(function (listener) {
            if (node instanceof ErrorNode || node.isErrorNode !== undefined && node.isErrorNode()) {
              listener.visitErrorNode(node);
            } else if (node instanceof TerminalNode) {
              listener.visitTerminal(node);
            }
          });
        }
      }

      return o;
    };

    Parser.prototype.addContextToParseTree = function () {
      // add current context to parent if we have a parent
      if (this._ctx.parentCtx !== null) {
        this._ctx.parentCtx.addChild(this._ctx);
      }
    }; // Always called by generated parsers upon entry to a rule. Access field
    // {@link //_ctx} get the current context.


    Parser.prototype.enterRule = function (localctx, state, ruleIndex) {
      this.state = state;
      this._ctx = localctx;
      this._ctx.start = this._input.LT(1);

      if (this.buildParseTrees) {
        this.addContextToParseTree();
      }

      if (this._parseListeners !== null) {
        this.triggerEnterRuleEvent();
      }
    };

    Parser.prototype.exitRule = function () {
      this._ctx.stop = this._input.LT(-1); // trigger event on _ctx, before it reverts to parent

      if (this._parseListeners !== null) {
        this.triggerExitRuleEvent();
      }

      this.state = this._ctx.invokingState;
      this._ctx = this._ctx.parentCtx;
    };

    Parser.prototype.enterOuterAlt = function (localctx, altNum) {
      localctx.setAltNumber(altNum); // if we have new localctx, make sure we replace existing ctx
      // that is previous child of parse tree

      if (this.buildParseTrees && this._ctx !== localctx) {
        if (this._ctx.parentCtx !== null) {
          this._ctx.parentCtx.removeLastChild();

          this._ctx.parentCtx.addChild(localctx);
        }
      }

      this._ctx = localctx;
    }; // Get the precedence level for the top-most precedence rule.
    //
    // @return The precedence level for the top-most precedence rule, or -1 if
    // the parser context is not nested within a precedence rule.


    Parser.prototype.getPrecedence = function () {
      if (this._precedenceStack.length === 0) {
        return -1;
      } else {
        return this._precedenceStack[this._precedenceStack.length - 1];
      }
    };

    Parser.prototype.enterRecursionRule = function (localctx, state, ruleIndex, precedence) {
      this.state = state;

      this._precedenceStack.push(precedence);

      this._ctx = localctx;
      this._ctx.start = this._input.LT(1);

      if (this._parseListeners !== null) {
        this.triggerEnterRuleEvent(); // simulates rule entry for
        // left-recursive rules
      }
    }; //
    // Like {@link //enterRule} but for recursive rules.


    Parser.prototype.pushNewRecursionContext = function (localctx, state, ruleIndex) {
      var previous = this._ctx;
      previous.parentCtx = localctx;
      previous.invokingState = state;
      previous.stop = this._input.LT(-1);
      this._ctx = localctx;
      this._ctx.start = previous.start;

      if (this.buildParseTrees) {
        this._ctx.addChild(previous);
      }

      if (this._parseListeners !== null) {
        this.triggerEnterRuleEvent(); // simulates rule entry for
        // left-recursive rules
      }
    };

    Parser.prototype.unrollRecursionContexts = function (parentCtx) {
      this._precedenceStack.pop();

      this._ctx.stop = this._input.LT(-1);
      var retCtx = this._ctx; // save current ctx (return value)
      // unroll so _ctx is as it was before call to recursive method

      if (this._parseListeners !== null) {
        while (this._ctx !== parentCtx) {
          this.triggerExitRuleEvent();
          this._ctx = this._ctx.parentCtx;
        }
      } else {
        this._ctx = parentCtx;
      } // hook into tree


      retCtx.parentCtx = parentCtx;

      if (this.buildParseTrees && parentCtx !== null) {
        // add return ctx into invoking rule's tree
        parentCtx.addChild(retCtx);
      }
    };

    Parser.prototype.getInvokingContext = function (ruleIndex) {
      var ctx = this._ctx;

      while (ctx !== null) {
        if (ctx.ruleIndex === ruleIndex) {
          return ctx;
        }

        ctx = ctx.parentCtx;
      }

      return null;
    };

    Parser.prototype.precpred = function (localctx, precedence) {
      return precedence >= this._precedenceStack[this._precedenceStack.length - 1];
    };

    Parser.prototype.inContext = function (context) {
      // TODO: useful in parser?
      return false;
    }; //
    // Checks whether or not {@code symbol} can follow the current state in the
    // ATN. The behavior of this method is equivalent to the following, but is
    // implemented such that the complete context-sensitive follow set does not
    // need to be explicitly constructed.
    //
    // <pre>
    // return getExpectedTokens().contains(symbol);
    // </pre>
    //
    // @param symbol the symbol type to check
    // @return {@code true} if {@code symbol} can follow the current state in
    // the ATN, otherwise {@code false}.


    Parser.prototype.isExpectedToken = function (symbol) {
      var atn = this._interp.atn;
      var ctx = this._ctx;
      var s = atn.states[this.state];
      var following = atn.nextTokens(s);

      if (following.contains(symbol)) {
        return true;
      }

      if (!following.contains(Token.EPSILON)) {
        return false;
      }

      while (ctx !== null && ctx.invokingState >= 0 && following.contains(Token.EPSILON)) {
        var invokingState = atn.states[ctx.invokingState];
        var rt = invokingState.transitions[0];
        following = atn.nextTokens(rt.followState);

        if (following.contains(symbol)) {
          return true;
        }

        ctx = ctx.parentCtx;
      }

      if (following.contains(Token.EPSILON) && symbol === Token.EOF) {
        return true;
      } else {
        return false;
      }
    }; // Computes the set of input symbols which could follow the current parser
    // state and context, as given by {@link //getState} and {@link //getContext},
    // respectively.
    //
    // @see ATN//getExpectedTokens(int, RuleContext)
    //


    Parser.prototype.getExpectedTokens = function () {
      return this._interp.atn.getExpectedTokens(this.state, this._ctx);
    };

    Parser.prototype.getExpectedTokensWithinCurrentRule = function () {
      var atn = this._interp.atn;
      var s = atn.states[this.state];
      return atn.nextTokens(s);
    }; // Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found.//


    Parser.prototype.getRuleIndex = function (ruleName) {
      var ruleIndex = this.getRuleIndexMap()[ruleName];

      if (ruleIndex !== null) {
        return ruleIndex;
      } else {
        return -1;
      }
    }; // Return List&lt;String&gt; of the rule names in your parser instance
    // leading up to a call to the current rule. You could override if
    // you want more details such as the file/line info of where
    // in the ATN a rule is invoked.
    //
    // this is very useful for error messages.
    //


    Parser.prototype.getRuleInvocationStack = function (p) {
      p = p || null;

      if (p === null) {
        p = this._ctx;
      }

      var stack = [];

      while (p !== null) {
        // compute what follows who invoked us
        var ruleIndex = p.ruleIndex;

        if (ruleIndex < 0) {
          stack.push("n/a");
        } else {
          stack.push(this.ruleNames[ruleIndex]);
        }

        p = p.parentCtx;
      }

      return stack;
    }; // For debugging and other purposes.//


    Parser.prototype.getDFAStrings = function () {
      return this._interp.decisionToDFA.toString();
    }; // For debugging and other purposes.//


    Parser.prototype.dumpDFA = function () {
      var seenOne = false;

      for (var i = 0; i < this._interp.decisionToDFA.length; i++) {
        var dfa = this._interp.decisionToDFA[i];

        if (dfa.states.length > 0) {
          if (seenOne) {
            console.log();
          }

          this.printer.println("Decision " + dfa.decision + ":");
          this.printer.print(dfa.toString(this.literalNames, this.symbolicNames));
          seenOne = true;
        }
      }
    };
    /*
    "			printer = function() {\r\n" +
    "				this.println = function(s) { document.getElementById('output') += s + '\\n'; }\r\n" +
    "				this.print = function(s) { document.getElementById('output') += s; }\r\n" +
    "			};\r\n" +
    */


    Parser.prototype.getSourceName = function () {
      return this._input.sourceName;
    }; // During a parse is sometimes useful to listen in on the rule entry and exit
    // events as well as token matches. this is for quick and dirty debugging.
    //


    Parser.prototype.setTrace = function (trace) {
      if (!trace) {
        this.removeParseListener(this._tracer);
        this._tracer = null;
      } else {
        if (this._tracer !== null) {
          this.removeParseListener(this._tracer);
        }

        this._tracer = new TraceListener(this);
        this.addParseListener(this._tracer);
      }
    };

    exports.Parser = Parser;
    /***/
  },

  /***/
  "./node_modules/antlr4/ParserRuleContext.js":
  /*!**************************************************!*\
    !*** ./node_modules/antlr4/ParserRuleContext.js ***!
    \**************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_ParserRuleContextJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //* A rule invocation record for parsing.
    //
    //  Contains all of the information about the current rule not stored in the
    //  RuleContext. It handles parse tree children list, Any ATN state
    //  tracing, and the default values available for rule indications:
    //  start, stop, rule index, current alt number, current
    //  ATN state.
    //
    //  Subclasses made for each rule and grammar track the parameters,
    //  return values, locals, and labels specific to that rule. These
    //  are the objects that are returned from rules.
    //
    //  Note text is not an actual field of a rule return value; it is computed
    //  from start and stop using the input stream's toString() method.  I
    //  could add a ctor to this so that we can pass in and store the input
    //  stream, but I'm not sure we want to do that.  It would seem to be undefined
    //  to get the .text property anyway if the rule matches tokens from multiple
    //  input streams.
    //
    //  I do not use getters for fields of objects that are used simply to
    //  group values such as this aggregate.  The getters/setters are there to
    //  satisfy the superclass interface.
    var RuleContext = __webpack_require__(
    /*! ./RuleContext */
    "./node_modules/antlr4/RuleContext.js").RuleContext;

    var Tree = __webpack_require__(
    /*! ./tree/Tree */
    "./node_modules/antlr4/tree/Tree.js");

    var INVALID_INTERVAL = Tree.INVALID_INTERVAL;
    var TerminalNode = Tree.TerminalNode;
    var TerminalNodeImpl = Tree.TerminalNodeImpl;
    var ErrorNodeImpl = Tree.ErrorNodeImpl;

    var Interval = __webpack_require__(
    /*! ./IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval;

    function ParserRuleContext(parent, invokingStateNumber) {
      parent = parent || null;
      invokingStateNumber = invokingStateNumber || null;
      RuleContext.call(this, parent, invokingStateNumber);
      this.ruleIndex = -1; // * If we are debugging or building a parse tree for a visitor,
      // we need to track all of the tokens and rule invocations associated
      // with this rule's context. This is empty for parsing w/o tree constr.
      // operation because we don't the need to track the details about
      // how we parse this rule.
      // /

      this.children = null;
      this.start = null;
      this.stop = null; // The exception that forced this rule to return. If the rule successfully
      // completed, this is {@code null}.

      this.exception = null;
    }

    ParserRuleContext.prototype = Object.create(RuleContext.prototype);
    ParserRuleContext.prototype.constructor = ParserRuleContext; // * COPY a ctx (I'm deliberately not using copy constructor)///

    ParserRuleContext.prototype.copyFrom = function (ctx) {
      // from RuleContext
      this.parentCtx = ctx.parentCtx;
      this.invokingState = ctx.invokingState;
      this.children = null;
      this.start = ctx.start;
      this.stop = ctx.stop; // copy any error nodes to alt label node

      if (ctx.children) {
        this.children = []; // reset parent pointer for any error nodes

        ctx.children.map(function (child) {
          if (child instanceof ErrorNodeImpl) {
            this.children.push(child);
            child.parentCtx = this;
          }
        }, this);
      }
    }; // Double dispatch methods for listeners


    ParserRuleContext.prototype.enterRule = function (listener) {};

    ParserRuleContext.prototype.exitRule = function (listener) {}; // * Does not set parent link; other add methods do that///


    ParserRuleContext.prototype.addChild = function (child) {
      if (this.children === null) {
        this.children = [];
      }

      this.children.push(child);
      return child;
    }; // * Used by enterOuterAlt to toss out a RuleContext previously added as
    // we entered a rule. If we have // label, we will need to remove
    // generic ruleContext object.
    // /


    ParserRuleContext.prototype.removeLastChild = function () {
      if (this.children !== null) {
        this.children.pop();
      }
    };

    ParserRuleContext.prototype.addTokenNode = function (token) {
      var node = new TerminalNodeImpl(token);
      this.addChild(node);
      node.parentCtx = this;
      return node;
    };

    ParserRuleContext.prototype.addErrorNode = function (badToken) {
      var node = new ErrorNodeImpl(badToken);
      this.addChild(node);
      node.parentCtx = this;
      return node;
    };

    ParserRuleContext.prototype.getChild = function (i, type) {
      type = type || null;

      if (this.children === null || i < 0 || i >= this.children.length) {
        return null;
      }

      if (type === null) {
        return this.children[i];
      } else {
        for (var j = 0; j < this.children.length; j++) {
          var child = this.children[j];

          if (child instanceof type) {
            if (i === 0) {
              return child;
            } else {
              i -= 1;
            }
          }
        }

        return null;
      }
    };

    ParserRuleContext.prototype.getToken = function (ttype, i) {
      if (this.children === null || i < 0 || i >= this.children.length) {
        return null;
      }

      for (var j = 0; j < this.children.length; j++) {
        var child = this.children[j];

        if (child instanceof TerminalNode) {
          if (child.symbol.type === ttype) {
            if (i === 0) {
              return child;
            } else {
              i -= 1;
            }
          }
        }
      }

      return null;
    };

    ParserRuleContext.prototype.getTokens = function (ttype) {
      if (this.children === null) {
        return [];
      } else {
        var tokens = [];

        for (var j = 0; j < this.children.length; j++) {
          var child = this.children[j];

          if (child instanceof TerminalNode) {
            if (child.symbol.type === ttype) {
              tokens.push(child);
            }
          }
        }

        return tokens;
      }
    };

    ParserRuleContext.prototype.getTypedRuleContext = function (ctxType, i) {
      return this.getChild(i, ctxType);
    };

    ParserRuleContext.prototype.getTypedRuleContexts = function (ctxType) {
      if (this.children === null) {
        return [];
      } else {
        var contexts = [];

        for (var j = 0; j < this.children.length; j++) {
          var child = this.children[j];

          if (child instanceof ctxType) {
            contexts.push(child);
          }
        }

        return contexts;
      }
    };

    ParserRuleContext.prototype.getChildCount = function () {
      if (this.children === null) {
        return 0;
      } else {
        return this.children.length;
      }
    };

    ParserRuleContext.prototype.getSourceInterval = function () {
      if (this.start === null || this.stop === null) {
        return INVALID_INTERVAL;
      } else {
        return new Interval(this.start.tokenIndex, this.stop.tokenIndex);
      }
    };

    RuleContext.EMPTY = new ParserRuleContext();

    function InterpreterRuleContext(parent, invokingStateNumber, ruleIndex) {
      ParserRuleContext.call(parent, invokingStateNumber);
      this.ruleIndex = ruleIndex;
      return this;
    }

    InterpreterRuleContext.prototype = Object.create(ParserRuleContext.prototype);
    InterpreterRuleContext.prototype.constructor = InterpreterRuleContext;
    exports.ParserRuleContext = ParserRuleContext;
    /***/
  },

  /***/
  "./node_modules/antlr4/PredictionContext.js":
  /*!**************************************************!*\
    !*** ./node_modules/antlr4/PredictionContext.js ***!
    \**************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_PredictionContextJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    var RuleContext = __webpack_require__(
    /*! ./RuleContext */
    "./node_modules/antlr4/RuleContext.js").RuleContext;

    var Hash = __webpack_require__(
    /*! ./Utils */
    "./node_modules/antlr4/Utils.js").Hash;

    function PredictionContext(cachedHashCode) {
      this.cachedHashCode = cachedHashCode;
    } // Represents {@code $} in local context prediction, which means wildcard.
    // {@code//+x =//}.
    // /


    PredictionContext.EMPTY = null; // Represents {@code $} in an array in full context mode, when {@code $}
    // doesn't mean wildcard: {@code $ + x = [$,x]}. Here,
    // {@code $} = {@link //EMPTY_RETURN_STATE}.
    // /

    PredictionContext.EMPTY_RETURN_STATE = 0x7FFFFFFF;
    PredictionContext.globalNodeCount = 1;
    PredictionContext.id = PredictionContext.globalNodeCount; // Stores the computed hash code of this {@link PredictionContext}. The hash
    // code is computed in parts to match the following reference algorithm.
    //
    // <pre>
    // private int referenceHashCode() {
    // int hash = {@link MurmurHash//initialize MurmurHash.initialize}({@link
    // //INITIAL_HASH});
    //
    // for (int i = 0; i &lt; {@link //size()}; i++) {
    // hash = {@link MurmurHash//update MurmurHash.update}(hash, {@link //getParent
    // getParent}(i));
    // }
    //
    // for (int i = 0; i &lt; {@link //size()}; i++) {
    // hash = {@link MurmurHash//update MurmurHash.update}(hash, {@link
    // //getReturnState getReturnState}(i));
    // }
    //
    // hash = {@link MurmurHash//finish MurmurHash.finish}(hash, 2// {@link
    // //size()});
    // return hash;
    // }
    // </pre>
    // /
    // This means only the {@link //EMPTY} context is in set.

    PredictionContext.prototype.isEmpty = function () {
      return this === PredictionContext.EMPTY;
    };

    PredictionContext.prototype.hasEmptyPath = function () {
      return this.getReturnState(this.length - 1) === PredictionContext.EMPTY_RETURN_STATE;
    };

    PredictionContext.prototype.hashCode = function () {
      return this.cachedHashCode;
    };

    PredictionContext.prototype.updateHashCode = function (hash) {
      hash.update(this.cachedHashCode);
    };
    /*
    function calculateHashString(parent, returnState) {
    	return "" + parent + returnState;
    }
    */
    // Used to cache {@link PredictionContext} objects. Its used for the shared
    // context cash associated with contexts in DFA states. This cache
    // can be used for both lexers and parsers.


    function PredictionContextCache() {
      this.cache = {};
      return this;
    } // Add a context to the cache and return it. If the context already exists,
    // return that one instead and do not add a new context to the cache.
    // Protect shared cache from unsafe thread access.
    //


    PredictionContextCache.prototype.add = function (ctx) {
      if (ctx === PredictionContext.EMPTY) {
        return PredictionContext.EMPTY;
      }

      var existing = this.cache[ctx] || null;

      if (existing !== null) {
        return existing;
      }

      this.cache[ctx] = ctx;
      return ctx;
    };

    PredictionContextCache.prototype.get = function (ctx) {
      return this.cache[ctx] || null;
    };

    Object.defineProperty(PredictionContextCache.prototype, "length", {
      get: function get() {
        return this.cache.length;
      }
    });

    function SingletonPredictionContext(parent, returnState) {
      var hashCode = 0;

      if (parent !== null) {
        var hash = new Hash();
        hash.update(parent, returnState);
        hashCode = hash.finish();
      }

      PredictionContext.call(this, hashCode);
      this.parentCtx = parent;
      this.returnState = returnState;
    }

    SingletonPredictionContext.prototype = Object.create(PredictionContext.prototype);
    SingletonPredictionContext.prototype.contructor = SingletonPredictionContext;

    SingletonPredictionContext.create = function (parent, returnState) {
      if (returnState === PredictionContext.EMPTY_RETURN_STATE && parent === null) {
        // someone can pass in the bits of an array ctx that mean $
        return PredictionContext.EMPTY;
      } else {
        return new SingletonPredictionContext(parent, returnState);
      }
    };

    Object.defineProperty(SingletonPredictionContext.prototype, "length", {
      get: function get() {
        return 1;
      }
    });

    SingletonPredictionContext.prototype.getParent = function (index) {
      return this.parentCtx;
    };

    SingletonPredictionContext.prototype.getReturnState = function (index) {
      return this.returnState;
    };

    SingletonPredictionContext.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof SingletonPredictionContext)) {
        return false;
      } else if (this.hashCode() !== other.hashCode()) {
        return false; // can't be same if hash is different
      } else {
        if (this.returnState !== other.returnState) return false;else if (this.parentCtx == null) return other.parentCtx == null;else return this.parentCtx.equals(other.parentCtx);
      }
    };

    SingletonPredictionContext.prototype.toString = function () {
      var up = this.parentCtx === null ? "" : this.parentCtx.toString();

      if (up.length === 0) {
        if (this.returnState === PredictionContext.EMPTY_RETURN_STATE) {
          return "$";
        } else {
          return "" + this.returnState;
        }
      } else {
        return "" + this.returnState + " " + up;
      }
    };

    function EmptyPredictionContext() {
      SingletonPredictionContext.call(this, null, PredictionContext.EMPTY_RETURN_STATE);
      return this;
    }

    EmptyPredictionContext.prototype = Object.create(SingletonPredictionContext.prototype);
    EmptyPredictionContext.prototype.constructor = EmptyPredictionContext;

    EmptyPredictionContext.prototype.isEmpty = function () {
      return true;
    };

    EmptyPredictionContext.prototype.getParent = function (index) {
      return null;
    };

    EmptyPredictionContext.prototype.getReturnState = function (index) {
      return this.returnState;
    };

    EmptyPredictionContext.prototype.equals = function (other) {
      return this === other;
    };

    EmptyPredictionContext.prototype.toString = function () {
      return "$";
    };

    PredictionContext.EMPTY = new EmptyPredictionContext();

    function ArrayPredictionContext(parents, returnStates) {
      // Parent can be null only if full ctx mode and we make an array
      // from {@link //EMPTY} and non-empty. We merge {@link //EMPTY} by using
      // null parent and
      // returnState == {@link //EMPTY_RETURN_STATE}.
      var h = new Hash();
      h.update(parents, returnStates);
      var hashCode = h.finish();
      PredictionContext.call(this, hashCode);
      this.parents = parents;
      this.returnStates = returnStates;
      return this;
    }

    ArrayPredictionContext.prototype = Object.create(PredictionContext.prototype);
    ArrayPredictionContext.prototype.constructor = ArrayPredictionContext;

    ArrayPredictionContext.prototype.isEmpty = function () {
      // since EMPTY_RETURN_STATE can only appear in the last position, we
      // don't need to verify that size==1
      return this.returnStates[0] === PredictionContext.EMPTY_RETURN_STATE;
    };

    Object.defineProperty(ArrayPredictionContext.prototype, "length", {
      get: function get() {
        return this.returnStates.length;
      }
    });

    ArrayPredictionContext.prototype.getParent = function (index) {
      return this.parents[index];
    };

    ArrayPredictionContext.prototype.getReturnState = function (index) {
      return this.returnStates[index];
    };

    ArrayPredictionContext.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof ArrayPredictionContext)) {
        return false;
      } else if (this.hashCode() !== other.hashCode()) {
        return false; // can't be same if hash is different
      } else {
        return this.returnStates === other.returnStates && this.parents === other.parents;
      }
    };

    ArrayPredictionContext.prototype.toString = function () {
      if (this.isEmpty()) {
        return "[]";
      } else {
        var s = "[";

        for (var i = 0; i < this.returnStates.length; i++) {
          if (i > 0) {
            s = s + ", ";
          }

          if (this.returnStates[i] === PredictionContext.EMPTY_RETURN_STATE) {
            s = s + "$";
            continue;
          }

          s = s + this.returnStates[i];

          if (this.parents[i] !== null) {
            s = s + " " + this.parents[i];
          } else {
            s = s + "null";
          }
        }

        return s + "]";
      }
    }; // Convert a {@link RuleContext} tree to a {@link PredictionContext} graph.
    // Return {@link //EMPTY} if {@code outerContext} is empty or null.
    // /


    function predictionContextFromRuleContext(atn, outerContext) {
      if (outerContext === undefined || outerContext === null) {
        outerContext = RuleContext.EMPTY;
      } // if we are in RuleContext of start rule, s, then PredictionContext
      // is EMPTY. Nobody called us. (if we are empty, return empty)


      if (outerContext.parentCtx === null || outerContext === RuleContext.EMPTY) {
        return PredictionContext.EMPTY;
      } // If we have a parent, convert it to a PredictionContext graph


      var parent = predictionContextFromRuleContext(atn, outerContext.parentCtx);
      var state = atn.states[outerContext.invokingState];
      var transition = state.transitions[0];
      return SingletonPredictionContext.create(parent, transition.followState.stateNumber);
    }
    /*
    function calculateListsHashString(parents, returnStates) {
    	var s = "";
    	parents.map(function(p) {
    		s = s + p;
    	});
    	returnStates.map(function(r) {
    		s = s + r;
    	});
    	return s;
    }
    */


    function merge(a, b, rootIsWildcard, mergeCache) {
      // share same graph if both same
      if (a === b) {
        return a;
      }

      if (a instanceof SingletonPredictionContext && b instanceof SingletonPredictionContext) {
        return mergeSingletons(a, b, rootIsWildcard, mergeCache);
      } // At least one of a or b is array
      // If one is $ and rootIsWildcard, return $ as// wildcard


      if (rootIsWildcard) {
        if (a instanceof EmptyPredictionContext) {
          return a;
        }

        if (b instanceof EmptyPredictionContext) {
          return b;
        }
      } // convert singleton so both are arrays to normalize


      if (a instanceof SingletonPredictionContext) {
        a = new ArrayPredictionContext([a.getParent()], [a.returnState]);
      }

      if (b instanceof SingletonPredictionContext) {
        b = new ArrayPredictionContext([b.getParent()], [b.returnState]);
      }

      return mergeArrays(a, b, rootIsWildcard, mergeCache);
    } //
    // Merge two {@link SingletonPredictionContext} instances.
    //
    // <p>Stack tops equal, parents merge is same; return left graph.<br>
    // <embed src="images/SingletonMerge_SameRootSamePar.svg"
    // type="image/svg+xml"/></p>
    //
    // <p>Same stack top, parents differ; merge parents giving array node, then
    // remainders of those graphs. A new root node is created to point to the
    // merged parents.<br>
    // <embed src="images/SingletonMerge_SameRootDiffPar.svg"
    // type="image/svg+xml"/></p>
    //
    // <p>Different stack tops pointing to same parent. Make array node for the
    // root where both element in the root point to the same (original)
    // parent.<br>
    // <embed src="images/SingletonMerge_DiffRootSamePar.svg"
    // type="image/svg+xml"/></p>
    //
    // <p>Different stack tops pointing to different parents. Make array node for
    // the root where each element points to the corresponding original
    // parent.<br>
    // <embed src="images/SingletonMerge_DiffRootDiffPar.svg"
    // type="image/svg+xml"/></p>
    //
    // @param a the first {@link SingletonPredictionContext}
    // @param b the second {@link SingletonPredictionContext}
    // @param rootIsWildcard {@code true} if this is a local-context merge,
    // otherwise false to indicate a full-context merge
    // @param mergeCache
    // /


    function mergeSingletons(a, b, rootIsWildcard, mergeCache) {
      if (mergeCache !== null) {
        var previous = mergeCache.get(a, b);

        if (previous !== null) {
          return previous;
        }

        previous = mergeCache.get(b, a);

        if (previous !== null) {
          return previous;
        }
      }

      var rootMerge = mergeRoot(a, b, rootIsWildcard);

      if (rootMerge !== null) {
        if (mergeCache !== null) {
          mergeCache.set(a, b, rootMerge);
        }

        return rootMerge;
      }

      if (a.returnState === b.returnState) {
        var parent = merge(a.parentCtx, b.parentCtx, rootIsWildcard, mergeCache); // if parent is same as existing a or b parent or reduced to a parent,
        // return it

        if (parent === a.parentCtx) {
          return a; // ax + bx = ax, if a=b
        }

        if (parent === b.parentCtx) {
          return b; // ax + bx = bx, if a=b
        } // else: ax + ay = a'[x,y]
        // merge parents x and y, giving array node with x,y then remainders
        // of those graphs. dup a, a' points at merged array
        // new joined parent so create new singleton pointing to it, a'


        var spc = SingletonPredictionContext.create(parent, a.returnState);

        if (mergeCache !== null) {
          mergeCache.set(a, b, spc);
        }

        return spc;
      } else {
        // a != b payloads differ
        // see if we can collapse parents due to $+x parents if local ctx
        var singleParent = null;

        if (a === b || a.parentCtx !== null && a.parentCtx === b.parentCtx) {
          // ax +
          // bx =
          // [a,b]x
          singleParent = a.parentCtx;
        }

        if (singleParent !== null) {
          // parents are same
          // sort payloads and use same parent
          var payloads = [a.returnState, b.returnState];

          if (a.returnState > b.returnState) {
            payloads[0] = b.returnState;
            payloads[1] = a.returnState;
          }

          var parents = [singleParent, singleParent];
          var apc = new ArrayPredictionContext(parents, payloads);

          if (mergeCache !== null) {
            mergeCache.set(a, b, apc);
          }

          return apc;
        } // parents differ and can't merge them. Just pack together
        // into array; can't merge.
        // ax + by = [ax,by]


        var payloads = [a.returnState, b.returnState];
        var parents = [a.parentCtx, b.parentCtx];

        if (a.returnState > b.returnState) {
          // sort by payload
          payloads[0] = b.returnState;
          payloads[1] = a.returnState;
          parents = [b.parentCtx, a.parentCtx];
        }

        var a_ = new ArrayPredictionContext(parents, payloads);

        if (mergeCache !== null) {
          mergeCache.set(a, b, a_);
        }

        return a_;
      }
    } //
    // Handle case where at least one of {@code a} or {@code b} is
    // {@link //EMPTY}. In the following diagrams, the symbol {@code $} is used
    // to represent {@link //EMPTY}.
    //
    // <h2>Local-Context Merges</h2>
    //
    // <p>These local-context merge operations are used when {@code rootIsWildcard}
    // is true.</p>
    //
    // <p>{@link //EMPTY} is superset of any graph; return {@link //EMPTY}.<br>
    // <embed src="images/LocalMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
    //
    // <p>{@link //EMPTY} and anything is {@code //EMPTY}, so merged parent is
    // {@code //EMPTY}; return left graph.<br>
    // <embed src="images/LocalMerge_EmptyParent.svg" type="image/svg+xml"/></p>
    //
    // <p>Special case of last merge if local context.<br>
    // <embed src="images/LocalMerge_DiffRoots.svg" type="image/svg+xml"/></p>
    //
    // <h2>Full-Context Merges</h2>
    //
    // <p>These full-context merge operations are used when {@code rootIsWildcard}
    // is false.</p>
    //
    // <p><embed src="images/FullMerge_EmptyRoots.svg" type="image/svg+xml"/></p>
    //
    // <p>Must keep all contexts; {@link //EMPTY} in array is a special value (and
    // null parent).<br>
    // <embed src="images/FullMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
    //
    // <p><embed src="images/FullMerge_SameRoot.svg" type="image/svg+xml"/></p>
    //
    // @param a the first {@link SingletonPredictionContext}
    // @param b the second {@link SingletonPredictionContext}
    // @param rootIsWildcard {@code true} if this is a local-context merge,
    // otherwise false to indicate a full-context merge
    // /


    function mergeRoot(a, b, rootIsWildcard) {
      if (rootIsWildcard) {
        if (a === PredictionContext.EMPTY) {
          return PredictionContext.EMPTY; // // + b =//
        }

        if (b === PredictionContext.EMPTY) {
          return PredictionContext.EMPTY; // a +// =//
        }
      } else {
        if (a === PredictionContext.EMPTY && b === PredictionContext.EMPTY) {
          return PredictionContext.EMPTY; // $ + $ = $
        } else if (a === PredictionContext.EMPTY) {
          // $ + x = [$,x]
          var payloads = [b.returnState, PredictionContext.EMPTY_RETURN_STATE];
          var parents = [b.parentCtx, null];
          return new ArrayPredictionContext(parents, payloads);
        } else if (b === PredictionContext.EMPTY) {
          // x + $ = [$,x] ($ is always first if present)
          var payloads = [a.returnState, PredictionContext.EMPTY_RETURN_STATE];
          var parents = [a.parentCtx, null];
          return new ArrayPredictionContext(parents, payloads);
        }
      }

      return null;
    } //
    // Merge two {@link ArrayPredictionContext} instances.
    //
    // <p>Different tops, different parents.<br>
    // <embed src="images/ArrayMerge_DiffTopDiffPar.svg" type="image/svg+xml"/></p>
    //
    // <p>Shared top, same parents.<br>
    // <embed src="images/ArrayMerge_ShareTopSamePar.svg" type="image/svg+xml"/></p>
    //
    // <p>Shared top, different parents.<br>
    // <embed src="images/ArrayMerge_ShareTopDiffPar.svg" type="image/svg+xml"/></p>
    //
    // <p>Shared top, all shared parents.<br>
    // <embed src="images/ArrayMerge_ShareTopSharePar.svg"
    // type="image/svg+xml"/></p>
    //
    // <p>Equal tops, merge parents and reduce top to
    // {@link SingletonPredictionContext}.<br>
    // <embed src="images/ArrayMerge_EqualTop.svg" type="image/svg+xml"/></p>
    // /


    function mergeArrays(a, b, rootIsWildcard, mergeCache) {
      if (mergeCache !== null) {
        var previous = mergeCache.get(a, b);

        if (previous !== null) {
          return previous;
        }

        previous = mergeCache.get(b, a);

        if (previous !== null) {
          return previous;
        }
      } // merge sorted payloads a + b => M


      var i = 0; // walks a

      var j = 0; // walks b

      var k = 0; // walks target M array

      var mergedReturnStates = [];
      var mergedParents = []; // walk and merge to yield mergedParents, mergedReturnStates

      while (i < a.returnStates.length && j < b.returnStates.length) {
        var a_parent = a.parents[i];
        var b_parent = b.parents[j];

        if (a.returnStates[i] === b.returnStates[j]) {
          // same payload (stack tops are equal), must yield merged singleton
          var payload = a.returnStates[i]; // $+$ = $

          var bothDollars = payload === PredictionContext.EMPTY_RETURN_STATE && a_parent === null && b_parent === null;
          var ax_ax = a_parent !== null && b_parent !== null && a_parent === b_parent; // ax+ax
          // ->
          // ax

          if (bothDollars || ax_ax) {
            mergedParents[k] = a_parent; // choose left

            mergedReturnStates[k] = payload;
          } else {
            // ax+ay -> a'[x,y]
            var mergedParent = merge(a_parent, b_parent, rootIsWildcard, mergeCache);
            mergedParents[k] = mergedParent;
            mergedReturnStates[k] = payload;
          }

          i += 1; // hop over left one as usual

          j += 1; // but also skip one in right side since we merge
        } else if (a.returnStates[i] < b.returnStates[j]) {
          // copy a[i] to M
          mergedParents[k] = a_parent;
          mergedReturnStates[k] = a.returnStates[i];
          i += 1;
        } else {
          // b > a, copy b[j] to M
          mergedParents[k] = b_parent;
          mergedReturnStates[k] = b.returnStates[j];
          j += 1;
        }

        k += 1;
      } // copy over any payloads remaining in either array


      if (i < a.returnStates.length) {
        for (var p = i; p < a.returnStates.length; p++) {
          mergedParents[k] = a.parents[p];
          mergedReturnStates[k] = a.returnStates[p];
          k += 1;
        }
      } else {
        for (var p = j; p < b.returnStates.length; p++) {
          mergedParents[k] = b.parents[p];
          mergedReturnStates[k] = b.returnStates[p];
          k += 1;
        }
      } // trim merged if we combined a few that had same stack tops


      if (k < mergedParents.length) {
        // write index < last position; trim
        if (k === 1) {
          // for just one merged element, return singleton top
          var a_ = SingletonPredictionContext.create(mergedParents[0], mergedReturnStates[0]);

          if (mergeCache !== null) {
            mergeCache.set(a, b, a_);
          }

          return a_;
        }

        mergedParents = mergedParents.slice(0, k);
        mergedReturnStates = mergedReturnStates.slice(0, k);
      }

      var M = new ArrayPredictionContext(mergedParents, mergedReturnStates); // if we created same array as a or b, return that instead
      // TODO: track whether this is possible above during merge sort for speed

      if (M === a) {
        if (mergeCache !== null) {
          mergeCache.set(a, b, a);
        }

        return a;
      }

      if (M === b) {
        if (mergeCache !== null) {
          mergeCache.set(a, b, b);
        }

        return b;
      }

      combineCommonParents(mergedParents);

      if (mergeCache !== null) {
        mergeCache.set(a, b, M);
      }

      return M;
    } //
    // Make pass over all <em>M</em> {@code parents}; merge any {@code equals()}
    // ones.
    // /


    function combineCommonParents(parents) {
      var uniqueParents = {};

      for (var p = 0; p < parents.length; p++) {
        var parent = parents[p];

        if (!(parent in uniqueParents)) {
          uniqueParents[parent] = parent;
        }
      }

      for (var q = 0; q < parents.length; q++) {
        parents[q] = uniqueParents[parents[q]];
      }
    }

    function getCachedPredictionContext(context, contextCache, visited) {
      if (context.isEmpty()) {
        return context;
      }

      var existing = visited[context] || null;

      if (existing !== null) {
        return existing;
      }

      existing = contextCache.get(context);

      if (existing !== null) {
        visited[context] = existing;
        return existing;
      }

      var changed = false;
      var parents = [];

      for (var i = 0; i < parents.length; i++) {
        var parent = getCachedPredictionContext(context.getParent(i), contextCache, visited);

        if (changed || parent !== context.getParent(i)) {
          if (!changed) {
            parents = [];

            for (var j = 0; j < context.length; j++) {
              parents[j] = context.getParent(j);
            }

            changed = true;
          }

          parents[i] = parent;
        }
      }

      if (!changed) {
        contextCache.add(context);
        visited[context] = context;
        return context;
      }

      var updated = null;

      if (parents.length === 0) {
        updated = PredictionContext.EMPTY;
      } else if (parents.length === 1) {
        updated = SingletonPredictionContext.create(parents[0], context.getReturnState(0));
      } else {
        updated = new ArrayPredictionContext(parents, context.returnStates);
      }

      contextCache.add(updated);
      visited[updated] = updated;
      visited[context] = updated;
      return updated;
    } // ter's recursive version of Sam's getAllNodes()


    function getAllContextNodes(context, nodes, visited) {
      if (nodes === null) {
        nodes = [];
        return getAllContextNodes(context, nodes, visited);
      } else if (visited === null) {
        visited = {};
        return getAllContextNodes(context, nodes, visited);
      } else {
        if (context === null || visited[context] !== null) {
          return nodes;
        }

        visited[context] = context;
        nodes.push(context);

        for (var i = 0; i < context.length; i++) {
          getAllContextNodes(context.getParent(i), nodes, visited);
        }

        return nodes;
      }
    }

    exports.merge = merge;
    exports.PredictionContext = PredictionContext;
    exports.PredictionContextCache = PredictionContextCache;
    exports.SingletonPredictionContext = SingletonPredictionContext;
    exports.predictionContextFromRuleContext = predictionContextFromRuleContext;
    exports.getCachedPredictionContext = getCachedPredictionContext;
    /***/
  },

  /***/
  "./node_modules/antlr4/Recognizer.js":
  /*!*******************************************!*\
    !*** ./node_modules/antlr4/Recognizer.js ***!
    \*******************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_RecognizerJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    var Token = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").Token;

    var ConsoleErrorListener = __webpack_require__(
    /*! ./error/ErrorListener */
    "./node_modules/antlr4/error/ErrorListener.js").ConsoleErrorListener;

    var ProxyErrorListener = __webpack_require__(
    /*! ./error/ErrorListener */
    "./node_modules/antlr4/error/ErrorListener.js").ProxyErrorListener;

    function Recognizer() {
      this._listeners = [ConsoleErrorListener.INSTANCE];
      this._interp = null;
      this._stateNumber = -1;
      return this;
    }

    Recognizer.tokenTypeMapCache = {};
    Recognizer.ruleIndexMapCache = {};

    Recognizer.prototype.checkVersion = function (toolVersion) {
      var runtimeVersion = "4.7.1";

      if (runtimeVersion !== toolVersion) {
        console.log("ANTLR runtime and generated code versions disagree: " + runtimeVersion + "!=" + toolVersion);
      }
    };

    Recognizer.prototype.addErrorListener = function (listener) {
      this._listeners.push(listener);
    };

    Recognizer.prototype.removeErrorListeners = function () {
      this._listeners = [];
    };

    Recognizer.prototype.getTokenTypeMap = function () {
      var tokenNames = this.getTokenNames();

      if (tokenNames === null) {
        throw "The current recognizer does not provide a list of token names.";
      }

      var result = this.tokenTypeMapCache[tokenNames];

      if (result === undefined) {
        result = tokenNames.reduce(function (o, k, i) {
          o[k] = i;
        });
        result.EOF = Token.EOF;
        this.tokenTypeMapCache[tokenNames] = result;
      }

      return result;
    }; // Get a map from rule names to rule indexes.
    //
    // <p>Used for XPath and tree pattern compilation.</p>
    //


    Recognizer.prototype.getRuleIndexMap = function () {
      var ruleNames = this.ruleNames;

      if (ruleNames === null) {
        throw "The current recognizer does not provide a list of rule names.";
      }

      var result = this.ruleIndexMapCache[ruleNames];

      if (result === undefined) {
        result = ruleNames.reduce(function (o, k, i) {
          o[k] = i;
        });
        this.ruleIndexMapCache[ruleNames] = result;
      }

      return result;
    };

    Recognizer.prototype.getTokenType = function (tokenName) {
      var ttype = this.getTokenTypeMap()[tokenName];

      if (ttype !== undefined) {
        return ttype;
      } else {
        return Token.INVALID_TYPE;
      }
    }; // What is the error header, normally line/character position information?//


    Recognizer.prototype.getErrorHeader = function (e) {
      var line = e.getOffendingToken().line;
      var column = e.getOffendingToken().column;
      return "line " + line + ":" + column;
    }; // How should a token be displayed in an error message? The default
    //  is to display just the text, but during development you might
    //  want to have a lot of information spit out.  Override in that case
    //  to use t.toString() (which, for CommonToken, dumps everything about
    //  the token). This is better than forcing you to override a method in
    //  your token objects because you don't have to go modify your lexer
    //  so that it creates a new Java type.
    //
    // @deprecated This method is not called by the ANTLR 4 Runtime. Specific
    // implementations of {@link ANTLRErrorStrategy} may provide a similar
    // feature when necessary. For example, see
    // {@link DefaultErrorStrategy//getTokenErrorDisplay}.
    //


    Recognizer.prototype.getTokenErrorDisplay = function (t) {
      if (t === null) {
        return "<no token>";
      }

      var s = t.text;

      if (s === null) {
        if (t.type === Token.EOF) {
          s = "<EOF>";
        } else {
          s = "<" + t.type + ">";
        }
      }

      s = s.replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t");
      return "'" + s + "'";
    };

    Recognizer.prototype.getErrorListenerDispatch = function () {
      return new ProxyErrorListener(this._listeners);
    }; // subclass needs to override these if there are sempreds or actions
    // that the ATN interp needs to execute


    Recognizer.prototype.sempred = function (localctx, ruleIndex, actionIndex) {
      return true;
    };

    Recognizer.prototype.precpred = function (localctx, precedence) {
      return true;
    }; //Indicate that the recognizer has changed internal state that is
    //consistent with the ATN state passed in.  This way we always know
    //where we are in the ATN as the parser goes along. The rule
    //context objects form a stack that lets us see the stack of
    //invoking rules. Combine this and we have complete ATN
    //configuration information.


    Object.defineProperty(Recognizer.prototype, "state", {
      get: function get() {
        return this._stateNumber;
      },
      set: function set(state) {
        this._stateNumber = state;
      }
    });
    exports.Recognizer = Recognizer;
    /***/
  },

  /***/
  "./node_modules/antlr4/RuleContext.js":
  /*!********************************************!*\
    !*** ./node_modules/antlr4/RuleContext.js ***!
    \********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_RuleContextJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    //  A rule context is a record of a single rule invocation. It knows
    //  which context invoked it, if any. If there is no parent context, then
    //  naturally the invoking state is not valid.  The parent link
    //  provides a chain upwards from the current rule invocation to the root
    //  of the invocation tree, forming a stack. We actually carry no
    //  information about the rule associated with this context (except
    //  when parsing). We keep only the state number of the invoking state from
    //  the ATN submachine that invoked this. Contrast this with the s
    //  pointer inside ParserRuleContext that tracks the current state
    //  being "executed" for the current rule.
    //
    //  The parent contexts are useful for computing lookahead sets and
    //  getting error information.
    //
    //  These objects are used during parsing and prediction.
    //  For the special case of parsers, we use the subclass
    //  ParserRuleContext.
    //
    //  @see ParserRuleContext
    ///
    var RuleNode = __webpack_require__(
    /*! ./tree/Tree */
    "./node_modules/antlr4/tree/Tree.js").RuleNode;

    var INVALID_INTERVAL = __webpack_require__(
    /*! ./tree/Tree */
    "./node_modules/antlr4/tree/Tree.js").INVALID_INTERVAL;

    var INVALID_ALT_NUMBER = __webpack_require__(
    /*! ./atn/ATN */
    "./node_modules/antlr4/atn/ATN.js").INVALID_ALT_NUMBER;

    function RuleContext(parent, invokingState) {
      RuleNode.call(this); // What context invoked this rule?

      this.parentCtx = parent || null; // What state invoked the rule associated with this context?
      // The "return address" is the followState of invokingState
      // If parent is null, this should be -1.

      this.invokingState = invokingState || -1;
      return this;
    }

    RuleContext.prototype = Object.create(RuleNode.prototype);
    RuleContext.prototype.constructor = RuleContext;

    RuleContext.prototype.depth = function () {
      var n = 0;
      var p = this;

      while (p !== null) {
        p = p.parentCtx;
        n += 1;
      }

      return n;
    }; // A context is empty if there is no invoking state; meaning nobody call
    // current context.


    RuleContext.prototype.isEmpty = function () {
      return this.invokingState === -1;
    }; // satisfy the ParseTree / SyntaxTree interface


    RuleContext.prototype.getSourceInterval = function () {
      return INVALID_INTERVAL;
    };

    RuleContext.prototype.getRuleContext = function () {
      return this;
    };

    RuleContext.prototype.getPayload = function () {
      return this;
    }; // Return the combined text of all child nodes. This method only considers
    // tokens which have been added to the parse tree.
    // <p>
    // Since tokens on hidden channels (e.g. whitespace or comments) are not
    // added to the parse trees, they will not appear in the output of this
    // method.
    // /


    RuleContext.prototype.getText = function () {
      if (this.getChildCount() === 0) {
        return "";
      } else {
        return this.children.map(function (child) {
          return child.getText();
        }).join("");
      }
    }; // For rule associated with this parse tree internal node, return
    // the outer alternative number used to match the input. Default
    // implementation does not compute nor store this alt num. Create
    // a subclass of ParserRuleContext with backing field and set
    // option contextSuperClass.
    // to set it.


    RuleContext.prototype.getAltNumber = function () {
      return INVALID_ALT_NUMBER;
    }; // Set the outer alternative number for this context node. Default
    // implementation does nothing to avoid backing field overhead for
    // trees that don't need it.  Create
    // a subclass of ParserRuleContext with backing field and set
    // option contextSuperClass.


    RuleContext.prototype.setAltNumber = function (altNumber) {};

    RuleContext.prototype.getChild = function (i) {
      return null;
    };

    RuleContext.prototype.getChildCount = function () {
      return 0;
    };

    RuleContext.prototype.accept = function (visitor) {
      return visitor.visitChildren(this);
    }; //need to manage circular dependencies, so export now


    exports.RuleContext = RuleContext;

    var Trees = __webpack_require__(
    /*! ./tree/Trees */
    "./node_modules/antlr4/tree/Trees.js").Trees; // Print out a whole tree, not just a node, in LISP format
    // (root child1 .. childN). Print just a node if this is a leaf.
    //


    RuleContext.prototype.toStringTree = function (ruleNames, recog) {
      return Trees.toStringTree(this, ruleNames, recog);
    };

    RuleContext.prototype.toString = function (ruleNames, stop) {
      ruleNames = ruleNames || null;
      stop = stop || null;
      var p = this;
      var s = "[";

      while (p !== null && p !== stop) {
        if (ruleNames === null) {
          if (!p.isEmpty()) {
            s += p.invokingState;
          }
        } else {
          var ri = p.ruleIndex;
          var ruleName = ri >= 0 && ri < ruleNames.length ? ruleNames[ri] : "" + ri;
          s += ruleName;
        }

        if (p.parentCtx !== null && (ruleNames !== null || !p.parentCtx.isEmpty())) {
          s += " ";
        }

        p = p.parentCtx;
      }

      s += "]";
      return s;
    };
    /***/

  },

  /***/
  "./node_modules/antlr4/Token.js":
  /*!**************************************!*\
    !*** ./node_modules/antlr4/Token.js ***!
    \**************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_TokenJs(module, exports) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    // A token has properties: text, type, line, character position in the line
    // (so we can ignore tabs), token channel, index, and source from which
    // we obtained this token.
    function Token() {
      this.source = null;
      this.type = null; // token type of the token

      this.channel = null; // The parser ignores everything not on DEFAULT_CHANNEL

      this.start = null; // optional; return -1 if not implemented.

      this.stop = null; // optional; return -1 if not implemented.

      this.tokenIndex = null; // from 0..n-1 of the token object in the input stream

      this.line = null; // line=1..n of the 1st character

      this.column = null; // beginning of the line at which it occurs, 0..n-1

      this._text = null; // text of the token.

      return this;
    }

    Token.INVALID_TYPE = 0; // During lookahead operations, this "token" signifies we hit rule end ATN state
    // and did not follow it despite needing to.

    Token.EPSILON = -2;
    Token.MIN_USER_TOKEN_TYPE = 1;
    Token.EOF = -1; // All tokens go to the parser (unless skip() is called in that rule)
    // on a particular "channel". The parser tunes to a particular channel
    // so that whitespace etc... can go to the parser on a "hidden" channel.

    Token.DEFAULT_CHANNEL = 0; // Anything on different channel than DEFAULT_CHANNEL is not parsed
    // by parser.

    Token.HIDDEN_CHANNEL = 1; // Explicitly set the text for this token. If {code text} is not
    // {@code null}, then {@link //getText} will return this value rather than
    // extracting the text from the input.
    //
    // @param text The explicit text of the token, or {@code null} if the text
    // should be obtained from the input along with the start and stop indexes
    // of the token.

    Object.defineProperty(Token.prototype, "text", {
      get: function get() {
        return this._text;
      },
      set: function set(text) {
        this._text = text;
      }
    });

    Token.prototype.getTokenSource = function () {
      return this.source[0];
    };

    Token.prototype.getInputStream = function () {
      return this.source[1];
    };

    function CommonToken(source, type, channel, start, stop) {
      Token.call(this);
      this.source = source !== undefined ? source : CommonToken.EMPTY_SOURCE;
      this.type = type !== undefined ? type : null;
      this.channel = channel !== undefined ? channel : Token.DEFAULT_CHANNEL;
      this.start = start !== undefined ? start : -1;
      this.stop = stop !== undefined ? stop : -1;
      this.tokenIndex = -1;

      if (this.source[0] !== null) {
        this.line = source[0].line;
        this.column = source[0].column;
      } else {
        this.column = -1;
      }

      return this;
    }

    CommonToken.prototype = Object.create(Token.prototype);
    CommonToken.prototype.constructor = CommonToken; // An empty {@link Pair} which is used as the default value of
    // {@link //source} for tokens that do not have a source.

    CommonToken.EMPTY_SOURCE = [null, null]; // Constructs a new {@link CommonToken} as a copy of another {@link Token}.
    //
    // <p>
    // If {@code oldToken} is also a {@link CommonToken} instance, the newly
    // constructed token will share a reference to the {@link //text} field and
    // the {@link Pair} stored in {@link //source}. Otherwise, {@link //text} will
    // be assigned the result of calling {@link //getText}, and {@link //source}
    // will be constructed from the result of {@link Token//getTokenSource} and
    // {@link Token//getInputStream}.</p>
    //
    // @param oldToken The token to copy.
    //

    CommonToken.prototype.clone = function () {
      var t = new CommonToken(this.source, this.type, this.channel, this.start, this.stop);
      t.tokenIndex = this.tokenIndex;
      t.line = this.line;
      t.column = this.column;
      t.text = this.text;
      return t;
    };

    Object.defineProperty(CommonToken.prototype, "text", {
      get: function get() {
        if (this._text !== null) {
          return this._text;
        }

        var input = this.getInputStream();

        if (input === null) {
          return null;
        }

        var n = input.size;

        if (this.start < n && this.stop < n) {
          return input.getText(this.start, this.stop);
        } else {
          return "<EOF>";
        }
      },
      set: function set(text) {
        this._text = text;
      }
    });

    CommonToken.prototype.toString = function () {
      var txt = this.text;

      if (txt !== null) {
        txt = txt.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
      } else {
        txt = "<no text>";
      }

      return "[@" + this.tokenIndex + "," + this.start + ":" + this.stop + "='" + txt + "',<" + this.type + ">" + (this.channel > 0 ? ",channel=" + this.channel : "") + "," + this.line + ":" + this.column + "]";
    };

    exports.Token = Token;
    exports.CommonToken = CommonToken;
    /***/
  },

  /***/
  "./node_modules/antlr4/Utils.js":
  /*!**************************************!*\
    !*** ./node_modules/antlr4/Utils.js ***!
    \**************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_UtilsJs(module, exports) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    function arrayToString(a) {
      return "[" + a.join(", ") + "]";
    }

    String.prototype.seed = String.prototype.seed || Math.round(Math.random() * Math.pow(2, 32));

    String.prototype.hashCode = function () {
      var remainder,
          bytes,
          h1,
          h1b,
          c1,
          c1b,
          c2,
          c2b,
          k1,
          i,
          key = this.toString();
      remainder = key.length & 3; // key.length % 4

      bytes = key.length - remainder;
      h1 = String.prototype.seed;
      c1 = 0xcc9e2d51;
      c2 = 0x1b873593;
      i = 0;

      while (i < bytes) {
        k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
        ++i;
        k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
        k1 = k1 << 15 | k1 >>> 17;
        k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
        h1 ^= k1;
        h1 = h1 << 13 | h1 >>> 19;
        h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
        h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
      }

      k1 = 0;

      switch (remainder) {
        case 3:
          k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;

        case 2:
          k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;

        case 1:
          k1 ^= key.charCodeAt(i) & 0xff;
          k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
          k1 = k1 << 15 | k1 >>> 17;
          k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
          h1 ^= k1;
      }

      h1 ^= key.length;
      h1 ^= h1 >>> 16;
      h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
      h1 ^= h1 >>> 13;
      h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
      h1 ^= h1 >>> 16;
      return h1 >>> 0;
    };

    function standardEqualsFunction(a, b) {
      return a.equals(b);
    }

    function standardHashCodeFunction(a) {
      return a.hashCode();
    }

    function Set(hashFunction, equalsFunction) {
      this.data = {};
      this.hashFunction = hashFunction || standardHashCodeFunction;
      this.equalsFunction = equalsFunction || standardEqualsFunction;
      return this;
    }

    Object.defineProperty(Set.prototype, "length", {
      get: function get() {
        var l = 0;

        for (var key in this.data) {
          if (key.indexOf("hash_") === 0) {
            l = l + this.data[key].length;
          }
        }

        return l;
      }
    });

    Set.prototype.add = function (value) {
      var hash = this.hashFunction(value);
      var key = "hash_" + hash;

      if (key in this.data) {
        var values = this.data[key];

        for (var i = 0; i < values.length; i++) {
          if (this.equalsFunction(value, values[i])) {
            return values[i];
          }
        }

        values.push(value);
        return value;
      } else {
        this.data[key] = [value];
        return value;
      }
    };

    Set.prototype.contains = function (value) {
      return this.get(value) != null;
    };

    Set.prototype.get = function (value) {
      var hash = this.hashFunction(value);
      var key = "hash_" + hash;

      if (key in this.data) {
        var values = this.data[key];

        for (var i = 0; i < values.length; i++) {
          if (this.equalsFunction(value, values[i])) {
            return values[i];
          }
        }
      }

      return null;
    };

    Set.prototype.values = function () {
      var l = [];

      for (var key in this.data) {
        if (key.indexOf("hash_") === 0) {
          l = l.concat(this.data[key]);
        }
      }

      return l;
    };

    Set.prototype.toString = function () {
      return arrayToString(this.values());
    };

    function BitSet() {
      this.data = [];
      return this;
    }

    BitSet.prototype.add = function (value) {
      this.data[value] = true;
    };

    BitSet.prototype.or = function (set) {
      var bits = this;
      Object.keys(set.data).map(function (alt) {
        bits.add(alt);
      });
    };

    BitSet.prototype.remove = function (value) {
      delete this.data[value];
    };

    BitSet.prototype.contains = function (value) {
      return this.data[value] === true;
    };

    BitSet.prototype.values = function () {
      return Object.keys(this.data);
    };

    BitSet.prototype.minValue = function () {
      return Math.min.apply(null, this.values());
    };

    BitSet.prototype.hashCode = function () {
      var hash = new Hash();
      hash.update(this.values());
      return hash.finish();
    };

    BitSet.prototype.equals = function (other) {
      if (!(other instanceof BitSet)) {
        return false;
      }

      return this.hashCode() === other.hashCode();
    };

    Object.defineProperty(BitSet.prototype, "length", {
      get: function get() {
        return this.values().length;
      }
    });

    BitSet.prototype.toString = function () {
      return "{" + this.values().join(", ") + "}";
    };

    function Map(hashFunction, equalsFunction) {
      this.data = {};
      this.hashFunction = hashFunction || standardHashCodeFunction;
      this.equalsFunction = equalsFunction || standardEqualsFunction;
      return this;
    }

    Object.defineProperty(Map.prototype, "length", {
      get: function get() {
        var l = 0;

        for (var hashKey in this.data) {
          if (hashKey.indexOf("hash_") === 0) {
            l = l + this.data[hashKey].length;
          }
        }

        return l;
      }
    });

    Map.prototype.put = function (key, value) {
      var hashKey = "hash_" + this.hashFunction(key);

      if (hashKey in this.data) {
        var entries = this.data[hashKey];

        for (var i = 0; i < entries.length; i++) {
          var entry = entries[i];

          if (this.equalsFunction(key, entry.key)) {
            var oldValue = entry.value;
            entry.value = value;
            return oldValue;
          }
        }

        entries.push({
          key: key,
          value: value
        });
        return value;
      } else {
        this.data[hashKey] = [{
          key: key,
          value: value
        }];
        return value;
      }
    };

    Map.prototype.containsKey = function (key) {
      var hashKey = "hash_" + this.hashFunction(key);

      if (hashKey in this.data) {
        var entries = this.data[hashKey];

        for (var i = 0; i < entries.length; i++) {
          var entry = entries[i];
          if (this.equalsFunction(key, entry.key)) return true;
        }
      }

      return false;
    };

    Map.prototype.get = function (key) {
      var hashKey = "hash_" + this.hashFunction(key);

      if (hashKey in this.data) {
        var entries = this.data[hashKey];

        for (var i = 0; i < entries.length; i++) {
          var entry = entries[i];
          if (this.equalsFunction(key, entry.key)) return entry.value;
        }
      }

      return null;
    };

    Map.prototype.entries = function () {
      var l = [];

      for (var key in this.data) {
        if (key.indexOf("hash_") === 0) {
          l = l.concat(this.data[key]);
        }
      }

      return l;
    };

    Map.prototype.getKeys = function () {
      return this.entries().map(function (e) {
        return e.key;
      });
    };

    Map.prototype.getValues = function () {
      return this.entries().map(function (e) {
        return e.value;
      });
    };

    Map.prototype.toString = function () {
      var ss = this.entries().map(function (entry) {
        return '{' + entry.key + ':' + entry.value + '}';
      });
      return '[' + ss.join(", ") + ']';
    };

    function AltDict() {
      this.data = {};
      return this;
    }

    AltDict.prototype.get = function (key) {
      key = "k-" + key;

      if (key in this.data) {
        return this.data[key];
      } else {
        return null;
      }
    };

    AltDict.prototype.put = function (key, value) {
      key = "k-" + key;
      this.data[key] = value;
    };

    AltDict.prototype.values = function () {
      var data = this.data;
      var keys = Object.keys(this.data);
      return keys.map(function (key) {
        return data[key];
      });
    };

    function DoubleDict() {
      return this;
    }

    function Hash() {
      this.count = 0;
      this.hash = 0;
      return this;
    }

    Hash.prototype.update = function () {
      for (var i = 0; i < arguments.length; i++) {
        var value = arguments[i];
        if (value == null) continue;
        if (Array.isArray(value)) this.update.apply(value);else {
          var k = 0;

          switch (typeof value) {
            case 'undefined':
            case 'function':
              continue;

            case 'number':
            case 'boolean':
              k = value;
              break;

            case 'string':
              k = value.hashCode();
              break;

            default:
              value.updateHashCode(this);
              continue;
          }

          k = k * 0xCC9E2D51;
          k = k << 15 | k >>> 32 - 15;
          k = k * 0x1B873593;
          this.count = this.count + 1;
          var hash = this.hash ^ k;
          hash = hash << 13 | hash >>> 32 - 13;
          hash = hash * 5 + 0xE6546B64;
          this.hash = hash;
        }
      }
    };

    Hash.prototype.finish = function () {
      var hash = this.hash ^ this.count * 4;
      hash = hash ^ hash >>> 16;
      hash = hash * 0x85EBCA6B;
      hash = hash ^ hash >>> 13;
      hash = hash * 0xC2B2AE35;
      hash = hash ^ hash >>> 16;
      return hash;
    };

    function hashStuff() {
      var hash = new Hash();
      hash.update.apply(arguments);
      return hash.finish();
    }

    DoubleDict.prototype.get = function (a, b) {
      var d = this[a] || null;
      return d === null ? null : d[b] || null;
    };

    DoubleDict.prototype.set = function (a, b, o) {
      var d = this[a] || null;

      if (d === null) {
        d = {};
        this[a] = d;
      }

      d[b] = o;
    };

    function escapeWhitespace(s, escapeSpaces) {
      s = s.replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r");

      if (escapeSpaces) {
        s = s.replace(/ /g, "\xB7");
      }

      return s;
    }

    function titleCase(str) {
      return str.replace(/\w\S*/g, function (txt) {
        return txt.charAt(0).toUpperCase() + txt.substr(1);
      });
    }

    ;

    function equalArrays(a, b) {
      if (!Array.isArray(a) || !Array.isArray(b)) return false;
      if (a == b) return true;
      if (a.length != b.length) return false;

      for (var i = 0; i < a.length; i++) {
        if (a[i] == b[i]) continue;
        if (!a[i].equals(b[i])) return false;
      }

      return true;
    }

    ;
    exports.Hash = Hash;
    exports.Set = Set;
    exports.Map = Map;
    exports.BitSet = BitSet;
    exports.AltDict = AltDict;
    exports.DoubleDict = DoubleDict;
    exports.hashStuff = hashStuff;
    exports.escapeWhitespace = escapeWhitespace;
    exports.arrayToString = arrayToString;
    exports.titleCase = titleCase;
    exports.equalArrays = equalArrays;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/ATN.js":
  /*!****************************************!*\
    !*** ./node_modules/antlr4/atn/ATN.js ***!
    \****************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_ATNJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    var LL1Analyzer = __webpack_require__(
    /*! ./../LL1Analyzer */
    "./node_modules/antlr4/LL1Analyzer.js").LL1Analyzer;

    var IntervalSet = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").IntervalSet;

    function ATN(grammarType, maxTokenType) {
      // Used for runtime deserialization of ATNs from strings///
      // The type of the ATN.
      this.grammarType = grammarType; // The maximum value for any symbol recognized by a transition in the ATN.

      this.maxTokenType = maxTokenType;
      this.states = []; // Each subrule/rule is a decision point and we must track them so we
      //  can go back later and build DFA predictors for them.  This includes
      //  all the rules, subrules, optional blocks, ()+, ()* etc...

      this.decisionToState = []; // Maps from rule index to starting state number.

      this.ruleToStartState = []; // Maps from rule index to stop state number.

      this.ruleToStopState = null;
      this.modeNameToStartState = {}; // For lexer ATNs, this maps the rule index to the resulting token type.
      // For parser ATNs, this maps the rule index to the generated bypass token
      // type if the
      // {@link ATNDeserializationOptions//isGenerateRuleBypassTransitions}
      // deserialization option was specified; otherwise, this is {@code null}.

      this.ruleToTokenType = null; // For lexer ATNs, this is an array of {@link LexerAction} objects which may
      // be referenced by action transitions in the ATN.

      this.lexerActions = null;
      this.modeToStartState = [];
      return this;
    } // Compute the set of valid tokens that can occur starting in state {@code s}.
    //  If {@code ctx} is null, the set of tokens will not include what can follow
    //  the rule surrounding {@code s}. In other words, the set will be
    //  restricted to tokens reachable staying within {@code s}'s rule.


    ATN.prototype.nextTokensInContext = function (s, ctx) {
      var anal = new LL1Analyzer(this);
      return anal.LOOK(s, null, ctx);
    }; // Compute the set of valid tokens that can occur starting in {@code s} and
    // staying in same rule. {@link Token//EPSILON} is in set if we reach end of
    // rule.


    ATN.prototype.nextTokensNoContext = function (s) {
      if (s.nextTokenWithinRule !== null) {
        return s.nextTokenWithinRule;
      }

      s.nextTokenWithinRule = this.nextTokensInContext(s, null);
      s.nextTokenWithinRule.readOnly = true;
      return s.nextTokenWithinRule;
    };

    ATN.prototype.nextTokens = function (s, ctx) {
      if (ctx === undefined) {
        return this.nextTokensNoContext(s);
      } else {
        return this.nextTokensInContext(s, ctx);
      }
    };

    ATN.prototype.addState = function (state) {
      if (state !== null) {
        state.atn = this;
        state.stateNumber = this.states.length;
      }

      this.states.push(state);
    };

    ATN.prototype.removeState = function (state) {
      this.states[state.stateNumber] = null; // just free mem, don't shift states in list
    };

    ATN.prototype.defineDecisionState = function (s) {
      this.decisionToState.push(s);
      s.decision = this.decisionToState.length - 1;
      return s.decision;
    };

    ATN.prototype.getDecisionState = function (decision) {
      if (this.decisionToState.length === 0) {
        return null;
      } else {
        return this.decisionToState[decision];
      }
    }; // Computes the set of input symbols which could follow ATN state number
    // {@code stateNumber} in the specified full {@code context}. This method
    // considers the complete parser context, but does not evaluate semantic
    // predicates (i.e. all predicates encountered during the calculation are
    // assumed true). If a path in the ATN exists from the starting state to the
    // {@link RuleStopState} of the outermost context without matching any
    // symbols, {@link Token//EOF} is added to the returned set.
    //
    // <p>If {@code context} is {@code null}, it is treated as
    // {@link ParserRuleContext//EMPTY}.</p>
    //
    // @param stateNumber the ATN state number
    // @param context the full parse context
    // @return The set of potentially valid input symbols which could follow the
    // specified state in the specified context.
    // @throws IllegalArgumentException if the ATN does not contain a state with
    // number {@code stateNumber}


    var Token = __webpack_require__(
    /*! ./../Token */
    "./node_modules/antlr4/Token.js").Token;

    ATN.prototype.getExpectedTokens = function (stateNumber, ctx) {
      if (stateNumber < 0 || stateNumber >= this.states.length) {
        throw "Invalid state number.";
      }

      var s = this.states[stateNumber];
      var following = this.nextTokens(s);

      if (!following.contains(Token.EPSILON)) {
        return following;
      }

      var expected = new IntervalSet();
      expected.addSet(following);
      expected.removeOne(Token.EPSILON);

      while (ctx !== null && ctx.invokingState >= 0 && following.contains(Token.EPSILON)) {
        var invokingState = this.states[ctx.invokingState];
        var rt = invokingState.transitions[0];
        following = this.nextTokens(rt.followState);
        expected.addSet(following);
        expected.removeOne(Token.EPSILON);
        ctx = ctx.parentCtx;
      }

      if (following.contains(Token.EPSILON)) {
        expected.addOne(Token.EOF);
      }

      return expected;
    };

    ATN.INVALID_ALT_NUMBER = 0;
    exports.ATN = ATN;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/ATNConfig.js":
  /*!**********************************************!*\
    !*** ./node_modules/antlr4/atn/ATNConfig.js ***!
    \**********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_ATNConfigJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    // A tuple: (ATN state, predicted alt, syntactic, semantic context).
    //  The syntactic context is a graph-structured stack node whose
    //  path(s) to the root is the rule invocation(s)
    //  chain used to arrive at the state.  The semantic context is
    //  the tree of semantic predicates encountered before reaching
    //  an ATN state.
    ///
    var DecisionState = __webpack_require__(
    /*! ./ATNState */
    "./node_modules/antlr4/atn/ATNState.js").DecisionState;

    var SemanticContext = __webpack_require__(
    /*! ./SemanticContext */
    "./node_modules/antlr4/atn/SemanticContext.js").SemanticContext;

    var Hash = __webpack_require__(
    /*! ../Utils */
    "./node_modules/antlr4/Utils.js").Hash;

    function checkParams(params, isCfg) {
      if (params === null) {
        var result = {
          state: null,
          alt: null,
          context: null,
          semanticContext: null
        };

        if (isCfg) {
          result.reachesIntoOuterContext = 0;
        }

        return result;
      } else {
        var props = {};
        props.state = params.state || null;
        props.alt = params.alt === undefined ? null : params.alt;
        props.context = params.context || null;
        props.semanticContext = params.semanticContext || null;

        if (isCfg) {
          props.reachesIntoOuterContext = params.reachesIntoOuterContext || 0;
          props.precedenceFilterSuppressed = params.precedenceFilterSuppressed || false;
        }

        return props;
      }
    }

    function ATNConfig(params, config) {
      this.checkContext(params, config);
      params = checkParams(params);
      config = checkParams(config, true); // The ATN state associated with this configuration///

      this.state = params.state !== null ? params.state : config.state; // What alt (or lexer rule) is predicted by this configuration///

      this.alt = params.alt !== null ? params.alt : config.alt; // The stack of invoking states leading to the rule/states associated
      //  with this config.  We track only those contexts pushed during
      //  execution of the ATN simulator.

      this.context = params.context !== null ? params.context : config.context;
      this.semanticContext = params.semanticContext !== null ? params.semanticContext : config.semanticContext !== null ? config.semanticContext : SemanticContext.NONE; // We cannot execute predicates dependent upon local context unless
      // we know for sure we are in the correct context. Because there is
      // no way to do this efficiently, we simply cannot evaluate
      // dependent predicates unless we are in the rule that initially
      // invokes the ATN simulator.
      //
      // closure() tracks the depth of how far we dip into the
      // outer context: depth &gt; 0.  Note that it may not be totally
      // accurate depth since I don't ever decrement. TODO: make it a boolean then

      this.reachesIntoOuterContext = config.reachesIntoOuterContext;
      this.precedenceFilterSuppressed = config.precedenceFilterSuppressed;
      return this;
    }

    ATNConfig.prototype.checkContext = function (params, config) {
      if ((params.context === null || params.context === undefined) && (config === null || config.context === null || config.context === undefined)) {
        this.context = null;
      }
    };

    ATNConfig.prototype.hashCode = function () {
      var hash = new Hash();
      this.updateHashCode(hash);
      return hash.finish();
    };

    ATNConfig.prototype.updateHashCode = function (hash) {
      hash.update(this.state.stateNumber, this.alt, this.context, this.semanticContext);
    }; // An ATN configuration is equal to another if both have
    //  the same state, they predict the same alternative, and
    //  syntactic/semantic contexts are the same.


    ATNConfig.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof ATNConfig)) {
        return false;
      } else {
        return this.state.stateNumber === other.state.stateNumber && this.alt === other.alt && (this.context === null ? other.context === null : this.context.equals(other.context)) && this.semanticContext.equals(other.semanticContext) && this.precedenceFilterSuppressed === other.precedenceFilterSuppressed;
      }
    };

    ATNConfig.prototype.hashCodeForConfigSet = function () {
      var hash = new Hash();
      hash.update(this.state.stateNumber, this.alt, this.semanticContext);
      return hash.finish();
    };

    ATNConfig.prototype.equalsForConfigSet = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof ATNConfig)) {
        return false;
      } else {
        return this.state.stateNumber === other.state.stateNumber && this.alt === other.alt && this.semanticContext.equals(other.semanticContext);
      }
    };

    ATNConfig.prototype.toString = function () {
      return "(" + this.state + "," + this.alt + (this.context !== null ? ",[" + this.context.toString() + "]" : "") + (this.semanticContext !== SemanticContext.NONE ? "," + this.semanticContext.toString() : "") + (this.reachesIntoOuterContext > 0 ? ",up=" + this.reachesIntoOuterContext : "") + ")";
    };

    function LexerATNConfig(params, config) {
      ATNConfig.call(this, params, config); // This is the backing field for {@link //getLexerActionExecutor}.

      var lexerActionExecutor = params.lexerActionExecutor || null;
      this.lexerActionExecutor = lexerActionExecutor || (config !== null ? config.lexerActionExecutor : null);
      this.passedThroughNonGreedyDecision = config !== null ? this.checkNonGreedyDecision(config, this.state) : false;
      return this;
    }

    LexerATNConfig.prototype = Object.create(ATNConfig.prototype);
    LexerATNConfig.prototype.constructor = LexerATNConfig;

    LexerATNConfig.prototype.updateHashCode = function (hash) {
      hash.update(this.state.stateNumber, this.alt, this.context, this.semanticContext, this.passedThroughNonGreedyDecision, this.lexerActionExecutor);
    };

    LexerATNConfig.prototype.equals = function (other) {
      return this === other || other instanceof LexerATNConfig && this.passedThroughNonGreedyDecision == other.passedThroughNonGreedyDecision && (this.lexerActionExecutor ? this.lexerActionExecutor.equals(other.lexerActionExecutor) : !other.lexerActionExecutor) && ATNConfig.prototype.equals.call(this, other);
    };

    LexerATNConfig.prototype.hashCodeForConfigSet = LexerATNConfig.prototype.hashCode;
    LexerATNConfig.prototype.equalsForConfigSet = LexerATNConfig.prototype.equals;

    LexerATNConfig.prototype.checkNonGreedyDecision = function (source, target) {
      return source.passedThroughNonGreedyDecision || target instanceof DecisionState && target.nonGreedy;
    };

    exports.ATNConfig = ATNConfig;
    exports.LexerATNConfig = LexerATNConfig;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/ATNConfigSet.js":
  /*!*************************************************!*\
    !*** ./node_modules/antlr4/atn/ATNConfigSet.js ***!
    \*************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_ATNConfigSetJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    // Specialized {@link Set}{@code <}{@link ATNConfig}{@code >} that can track
    // info about the set, with support for combining similar configurations using a
    // graph-structured stack.
    ///
    var ATN = __webpack_require__(
    /*! ./ATN */
    "./node_modules/antlr4/atn/ATN.js").ATN;

    var Utils = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js");

    var Hash = Utils.Hash;
    var Set = Utils.Set;

    var SemanticContext = __webpack_require__(
    /*! ./SemanticContext */
    "./node_modules/antlr4/atn/SemanticContext.js").SemanticContext;

    var merge = __webpack_require__(
    /*! ./../PredictionContext */
    "./node_modules/antlr4/PredictionContext.js").merge;

    function hashATNConfig(c) {
      return c.hashCodeForConfigSet();
    }

    function equalATNConfigs(a, b) {
      if (a === b) {
        return true;
      } else if (a === null || b === null) {
        return false;
      } else return a.equalsForConfigSet(b);
    }

    function ATNConfigSet(fullCtx) {
      //
      // The reason that we need this is because we don't want the hash map to use
      // the standard hash code and equals. We need all configurations with the
      // same
      // {@code (s,i,_,semctx)} to be equal. Unfortunately, this key effectively
      // doubles
      // the number of objects associated with ATNConfigs. The other solution is
      // to
      // use a hash table that lets us specify the equals/hashcode operation.
      // All configs but hashed by (s, i, _, pi) not including context. Wiped out
      // when we go readonly as this set becomes a DFA state.
      this.configLookup = new Set(hashATNConfig, equalATNConfigs); // Indicates that this configuration set is part of a full context
      // LL prediction. It will be used to determine how to merge $. With SLL
      // it's a wildcard whereas it is not for LL context merge.

      this.fullCtx = fullCtx === undefined ? true : fullCtx; // Indicates that the set of configurations is read-only. Do not
      // allow any code to manipulate the set; DFA states will point at
      // the sets and they must not change. This does not protect the other
      // fields; in particular, conflictingAlts is set after
      // we've made this readonly.

      this.readOnly = false; // Track the elements as they are added to the set; supports get(i)///

      this.configs = []; // TODO: these fields make me pretty uncomfortable but nice to pack up info
      // together, saves recomputation
      // TODO: can we track conflicts as they are added to save scanning configs
      // later?

      this.uniqueAlt = 0;
      this.conflictingAlts = null; // Used in parser and lexer. In lexer, it indicates we hit a pred
      // while computing a closure operation. Don't make a DFA state from this.

      this.hasSemanticContext = false;
      this.dipsIntoOuterContext = false;
      this.cachedHashCode = -1;
      return this;
    } // Adding a new config means merging contexts with existing configs for
    // {@code (s, i, pi, _)}, where {@code s} is the
    // {@link ATNConfig//state}, {@code i} is the {@link ATNConfig//alt}, and
    // {@code pi} is the {@link ATNConfig//semanticContext}. We use
    // {@code (s,i,pi)} as key.
    //
    // <p>This method updates {@link //dipsIntoOuterContext} and
    // {@link //hasSemanticContext} when necessary.</p>
    // /


    ATNConfigSet.prototype.add = function (config, mergeCache) {
      if (mergeCache === undefined) {
        mergeCache = null;
      }

      if (this.readOnly) {
        throw "This set is readonly";
      }

      if (config.semanticContext !== SemanticContext.NONE) {
        this.hasSemanticContext = true;
      }

      if (config.reachesIntoOuterContext > 0) {
        this.dipsIntoOuterContext = true;
      }

      var existing = this.configLookup.add(config);

      if (existing === config) {
        this.cachedHashCode = -1;
        this.configs.push(config); // track order here

        return true;
      } // a previous (s,i,pi,_), merge with it and save result


      var rootIsWildcard = !this.fullCtx;
      var merged = merge(existing.context, config.context, rootIsWildcard, mergeCache); // no need to check for existing.context, config.context in cache
      // since only way to create new graphs is "call rule" and here. We
      // cache at both places.

      existing.reachesIntoOuterContext = Math.max(existing.reachesIntoOuterContext, config.reachesIntoOuterContext); // make sure to preserve the precedence filter suppression during the merge

      if (config.precedenceFilterSuppressed) {
        existing.precedenceFilterSuppressed = true;
      }

      existing.context = merged; // replace context; no need to alt mapping

      return true;
    };

    ATNConfigSet.prototype.getStates = function () {
      var states = new Set();

      for (var i = 0; i < this.configs.length; i++) {
        states.add(this.configs[i].state);
      }

      return states;
    };

    ATNConfigSet.prototype.getPredicates = function () {
      var preds = [];

      for (var i = 0; i < this.configs.length; i++) {
        var c = this.configs[i].semanticContext;

        if (c !== SemanticContext.NONE) {
          preds.push(c.semanticContext);
        }
      }

      return preds;
    };

    Object.defineProperty(ATNConfigSet.prototype, "items", {
      get: function get() {
        return this.configs;
      }
    });

    ATNConfigSet.prototype.optimizeConfigs = function (interpreter) {
      if (this.readOnly) {
        throw "This set is readonly";
      }

      if (this.configLookup.length === 0) {
        return;
      }

      for (var i = 0; i < this.configs.length; i++) {
        var config = this.configs[i];
        config.context = interpreter.getCachedContext(config.context);
      }
    };

    ATNConfigSet.prototype.addAll = function (coll) {
      for (var i = 0; i < coll.length; i++) {
        this.add(coll[i]);
      }

      return false;
    };

    ATNConfigSet.prototype.equals = function (other) {
      return this === other || other instanceof ATNConfigSet && Utils.equalArrays(this.configs, other.configs) && this.fullCtx === other.fullCtx && this.uniqueAlt === other.uniqueAlt && this.conflictingAlts === other.conflictingAlts && this.hasSemanticContext === other.hasSemanticContext && this.dipsIntoOuterContext === other.dipsIntoOuterContext;
    };

    ATNConfigSet.prototype.hashCode = function () {
      var hash = new Hash();
      this.updateHashCode(hash);
      return hash.finish();
    };

    ATNConfigSet.prototype.updateHashCode = function (hash) {
      if (this.readOnly) {
        if (this.cachedHashCode === -1) {
          var hash = new Hash();
          hash.update(this.configs);
          this.cachedHashCode = hash.finish();
        }

        hash.update(this.cachedHashCode);
      } else {
        hash.update(this.configs);
      }
    };

    Object.defineProperty(ATNConfigSet.prototype, "length", {
      get: function get() {
        return this.configs.length;
      }
    });

    ATNConfigSet.prototype.isEmpty = function () {
      return this.configs.length === 0;
    };

    ATNConfigSet.prototype.contains = function (item) {
      if (this.configLookup === null) {
        throw "This method is not implemented for readonly sets.";
      }

      return this.configLookup.contains(item);
    };

    ATNConfigSet.prototype.containsFast = function (item) {
      if (this.configLookup === null) {
        throw "This method is not implemented for readonly sets.";
      }

      return this.configLookup.containsFast(item);
    };

    ATNConfigSet.prototype.clear = function () {
      if (this.readOnly) {
        throw "This set is readonly";
      }

      this.configs = [];
      this.cachedHashCode = -1;
      this.configLookup = new Set();
    };

    ATNConfigSet.prototype.setReadonly = function (readOnly) {
      this.readOnly = readOnly;

      if (readOnly) {
        this.configLookup = null; // can't mod, no need for lookup cache
      }
    };

    ATNConfigSet.prototype.toString = function () {
      return Utils.arrayToString(this.configs) + (this.hasSemanticContext ? ",hasSemanticContext=" + this.hasSemanticContext : "") + (this.uniqueAlt !== ATN.INVALID_ALT_NUMBER ? ",uniqueAlt=" + this.uniqueAlt : "") + (this.conflictingAlts !== null ? ",conflictingAlts=" + this.conflictingAlts : "") + (this.dipsIntoOuterContext ? ",dipsIntoOuterContext" : "");
    };

    function OrderedATNConfigSet() {
      ATNConfigSet.call(this);
      this.configLookup = new Set();
      return this;
    }

    OrderedATNConfigSet.prototype = Object.create(ATNConfigSet.prototype);
    OrderedATNConfigSet.prototype.constructor = OrderedATNConfigSet;
    exports.ATNConfigSet = ATNConfigSet;
    exports.OrderedATNConfigSet = OrderedATNConfigSet;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/ATNDeserializationOptions.js":
  /*!**************************************************************!*\
    !*** ./node_modules/antlr4/atn/ATNDeserializationOptions.js ***!
    \**************************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_ATNDeserializationOptionsJs(module, exports) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    function ATNDeserializationOptions(copyFrom) {
      if (copyFrom === undefined) {
        copyFrom = null;
      }

      this.readOnly = false;
      this.verifyATN = copyFrom === null ? true : copyFrom.verifyATN;
      this.generateRuleBypassTransitions = copyFrom === null ? false : copyFrom.generateRuleBypassTransitions;
      return this;
    }

    ATNDeserializationOptions.defaultOptions = new ATNDeserializationOptions();
    ATNDeserializationOptions.defaultOptions.readOnly = true; //    def __setattr__(self, key, value):
    //        if key!="readOnly" and self.readOnly:
    //            raise Exception("The object is read only.")
    //        super(type(self), self).__setattr__(key,value)

    exports.ATNDeserializationOptions = ATNDeserializationOptions;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/ATNDeserializer.js":
  /*!****************************************************!*\
    !*** ./node_modules/antlr4/atn/ATNDeserializer.js ***!
    \****************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_ATNDeserializerJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    var Token = __webpack_require__(
    /*! ./../Token */
    "./node_modules/antlr4/Token.js").Token;

    var ATN = __webpack_require__(
    /*! ./ATN */
    "./node_modules/antlr4/atn/ATN.js").ATN;

    var ATNType = __webpack_require__(
    /*! ./ATNType */
    "./node_modules/antlr4/atn/ATNType.js").ATNType;

    var ATNStates = __webpack_require__(
    /*! ./ATNState */
    "./node_modules/antlr4/atn/ATNState.js");

    var ATNState = ATNStates.ATNState;
    var BasicState = ATNStates.BasicState;
    var DecisionState = ATNStates.DecisionState;
    var BlockStartState = ATNStates.BlockStartState;
    var BlockEndState = ATNStates.BlockEndState;
    var LoopEndState = ATNStates.LoopEndState;
    var RuleStartState = ATNStates.RuleStartState;
    var RuleStopState = ATNStates.RuleStopState;
    var TokensStartState = ATNStates.TokensStartState;
    var PlusLoopbackState = ATNStates.PlusLoopbackState;
    var StarLoopbackState = ATNStates.StarLoopbackState;
    var StarLoopEntryState = ATNStates.StarLoopEntryState;
    var PlusBlockStartState = ATNStates.PlusBlockStartState;
    var StarBlockStartState = ATNStates.StarBlockStartState;
    var BasicBlockStartState = ATNStates.BasicBlockStartState;

    var Transitions = __webpack_require__(
    /*! ./Transition */
    "./node_modules/antlr4/atn/Transition.js");

    var Transition = Transitions.Transition;
    var AtomTransition = Transitions.AtomTransition;
    var SetTransition = Transitions.SetTransition;
    var NotSetTransition = Transitions.NotSetTransition;
    var RuleTransition = Transitions.RuleTransition;
    var RangeTransition = Transitions.RangeTransition;
    var ActionTransition = Transitions.ActionTransition;
    var EpsilonTransition = Transitions.EpsilonTransition;
    var WildcardTransition = Transitions.WildcardTransition;
    var PredicateTransition = Transitions.PredicateTransition;
    var PrecedencePredicateTransition = Transitions.PrecedencePredicateTransition;

    var IntervalSet = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").IntervalSet;

    var Interval = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval;

    var ATNDeserializationOptions = __webpack_require__(
    /*! ./ATNDeserializationOptions */
    "./node_modules/antlr4/atn/ATNDeserializationOptions.js").ATNDeserializationOptions;

    var LexerActions = __webpack_require__(
    /*! ./LexerAction */
    "./node_modules/antlr4/atn/LexerAction.js");

    var LexerActionType = LexerActions.LexerActionType;
    var LexerSkipAction = LexerActions.LexerSkipAction;
    var LexerChannelAction = LexerActions.LexerChannelAction;
    var LexerCustomAction = LexerActions.LexerCustomAction;
    var LexerMoreAction = LexerActions.LexerMoreAction;
    var LexerTypeAction = LexerActions.LexerTypeAction;
    var LexerPushModeAction = LexerActions.LexerPushModeAction;
    var LexerPopModeAction = LexerActions.LexerPopModeAction;
    var LexerModeAction = LexerActions.LexerModeAction; // This is the earliest supported serialized UUID.
    // stick to serialized version for now, we don't need a UUID instance

    var BASE_SERIALIZED_UUID = "AADB8D7E-AEEF-4415-AD2B-8204D6CF042E"; //
    // This UUID indicates the serialized ATN contains two sets of
    // IntervalSets, where the second set's values are encoded as
    // 32-bit integers to support the full Unicode SMP range up to U+10FFFF.
    //

    var ADDED_UNICODE_SMP = "59627784-3BE5-417A-B9EB-8131A7286089"; // This list contains all of the currently supported UUIDs, ordered by when
    // the feature first appeared in this branch.

    var SUPPORTED_UUIDS = [BASE_SERIALIZED_UUID, ADDED_UNICODE_SMP];
    var SERIALIZED_VERSION = 3; // This is the current serialized UUID.

    var SERIALIZED_UUID = ADDED_UNICODE_SMP;

    function initArray(length, value) {
      var tmp = [];
      tmp[length - 1] = value;
      return tmp.map(function (i) {
        return value;
      });
    }

    function ATNDeserializer(options) {
      if (options === undefined || options === null) {
        options = ATNDeserializationOptions.defaultOptions;
      }

      this.deserializationOptions = options;
      this.stateFactories = null;
      this.actionFactories = null;
      return this;
    } // Determines if a particular serialized representation of an ATN supports
    // a particular feature, identified by the {@link UUID} used for serializing
    // the ATN at the time the feature was first introduced.
    //
    // @param feature The {@link UUID} marking the first time the feature was
    // supported in the serialized ATN.
    // @param actualUuid The {@link UUID} of the actual serialized ATN which is
    // currently being deserialized.
    // @return {@code true} if the {@code actualUuid} value represents a
    // serialized ATN at or after the feature identified by {@code feature} was
    // introduced; otherwise, {@code false}.


    ATNDeserializer.prototype.isFeatureSupported = function (feature, actualUuid) {
      var idx1 = SUPPORTED_UUIDS.indexOf(feature);

      if (idx1 < 0) {
        return false;
      }

      var idx2 = SUPPORTED_UUIDS.indexOf(actualUuid);
      return idx2 >= idx1;
    };

    ATNDeserializer.prototype.deserialize = function (data) {
      this.reset(data);
      this.checkVersion();
      this.checkUUID();
      var atn = this.readATN();
      this.readStates(atn);
      this.readRules(atn);
      this.readModes(atn);
      var sets = []; // First, deserialize sets with 16-bit arguments <= U+FFFF.

      this.readSets(atn, sets, this.readInt.bind(this)); // Next, if the ATN was serialized with the Unicode SMP feature,
      // deserialize sets with 32-bit arguments <= U+10FFFF.

      if (this.isFeatureSupported(ADDED_UNICODE_SMP, this.uuid)) {
        this.readSets(atn, sets, this.readInt32.bind(this));
      }

      this.readEdges(atn, sets);
      this.readDecisions(atn);
      this.readLexerActions(atn);
      this.markPrecedenceDecisions(atn);
      this.verifyATN(atn);

      if (this.deserializationOptions.generateRuleBypassTransitions && atn.grammarType === ATNType.PARSER) {
        this.generateRuleBypassTransitions(atn); // re-verify after modification

        this.verifyATN(atn);
      }

      return atn;
    };

    ATNDeserializer.prototype.reset = function (data) {
      var adjust = function adjust(c) {
        var v = c.charCodeAt(0);
        return v > 1 ? v - 2 : v + 65533;
      };

      var temp = data.split("").map(adjust); // don't adjust the first value since that's the version number

      temp[0] = data.charCodeAt(0);
      this.data = temp;
      this.pos = 0;
    };

    ATNDeserializer.prototype.checkVersion = function () {
      var version = this.readInt();

      if (version !== SERIALIZED_VERSION) {
        throw "Could not deserialize ATN with version " + version + " (expected " + SERIALIZED_VERSION + ").";
      }
    };

    ATNDeserializer.prototype.checkUUID = function () {
      var uuid = this.readUUID();

      if (SUPPORTED_UUIDS.indexOf(uuid) < 0) {
        throw "Could not deserialize ATN with UUID: " + uuid + " (expected " + SERIALIZED_UUID + " or a legacy UUID).", uuid, SERIALIZED_UUID;
      }

      this.uuid = uuid;
    };

    ATNDeserializer.prototype.readATN = function () {
      var grammarType = this.readInt();
      var maxTokenType = this.readInt();
      return new ATN(grammarType, maxTokenType);
    };

    ATNDeserializer.prototype.readStates = function (atn) {
      var j, pair, stateNumber;
      var loopBackStateNumbers = [];
      var endStateNumbers = [];
      var nstates = this.readInt();

      for (var i = 0; i < nstates; i++) {
        var stype = this.readInt(); // ignore bad type of states

        if (stype === ATNState.INVALID_TYPE) {
          atn.addState(null);
          continue;
        }

        var ruleIndex = this.readInt();

        if (ruleIndex === 0xFFFF) {
          ruleIndex = -1;
        }

        var s = this.stateFactory(stype, ruleIndex);

        if (stype === ATNState.LOOP_END) {
          // special case
          var loopBackStateNumber = this.readInt();
          loopBackStateNumbers.push([s, loopBackStateNumber]);
        } else if (s instanceof BlockStartState) {
          var endStateNumber = this.readInt();
          endStateNumbers.push([s, endStateNumber]);
        }

        atn.addState(s);
      } // delay the assignment of loop back and end states until we know all the
      // state instances have been initialized


      for (j = 0; j < loopBackStateNumbers.length; j++) {
        pair = loopBackStateNumbers[j];
        pair[0].loopBackState = atn.states[pair[1]];
      }

      for (j = 0; j < endStateNumbers.length; j++) {
        pair = endStateNumbers[j];
        pair[0].endState = atn.states[pair[1]];
      }

      var numNonGreedyStates = this.readInt();

      for (j = 0; j < numNonGreedyStates; j++) {
        stateNumber = this.readInt();
        atn.states[stateNumber].nonGreedy = true;
      }

      var numPrecedenceStates = this.readInt();

      for (j = 0; j < numPrecedenceStates; j++) {
        stateNumber = this.readInt();
        atn.states[stateNumber].isPrecedenceRule = true;
      }
    };

    ATNDeserializer.prototype.readRules = function (atn) {
      var i;
      var nrules = this.readInt();

      if (atn.grammarType === ATNType.LEXER) {
        atn.ruleToTokenType = initArray(nrules, 0);
      }

      atn.ruleToStartState = initArray(nrules, 0);

      for (i = 0; i < nrules; i++) {
        var s = this.readInt();
        var startState = atn.states[s];
        atn.ruleToStartState[i] = startState;

        if (atn.grammarType === ATNType.LEXER) {
          var tokenType = this.readInt();

          if (tokenType === 0xFFFF) {
            tokenType = Token.EOF;
          }

          atn.ruleToTokenType[i] = tokenType;
        }
      }

      atn.ruleToStopState = initArray(nrules, 0);

      for (i = 0; i < atn.states.length; i++) {
        var state = atn.states[i];

        if (!(state instanceof RuleStopState)) {
          continue;
        }

        atn.ruleToStopState[state.ruleIndex] = state;
        atn.ruleToStartState[state.ruleIndex].stopState = state;
      }
    };

    ATNDeserializer.prototype.readModes = function (atn) {
      var nmodes = this.readInt();

      for (var i = 0; i < nmodes; i++) {
        var s = this.readInt();
        atn.modeToStartState.push(atn.states[s]);
      }
    };

    ATNDeserializer.prototype.readSets = function (atn, sets, readUnicode) {
      var m = this.readInt();

      for (var i = 0; i < m; i++) {
        var iset = new IntervalSet();
        sets.push(iset);
        var n = this.readInt();
        var containsEof = this.readInt();

        if (containsEof !== 0) {
          iset.addOne(-1);
        }

        for (var j = 0; j < n; j++) {
          var i1 = readUnicode();
          var i2 = readUnicode();
          iset.addRange(i1, i2);
        }
      }
    };

    ATNDeserializer.prototype.readEdges = function (atn, sets) {
      var i, j, state, trans, target;
      var nedges = this.readInt();

      for (i = 0; i < nedges; i++) {
        var src = this.readInt();
        var trg = this.readInt();
        var ttype = this.readInt();
        var arg1 = this.readInt();
        var arg2 = this.readInt();
        var arg3 = this.readInt();
        trans = this.edgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets);
        var srcState = atn.states[src];
        srcState.addTransition(trans);
      } // edges for rule stop states can be derived, so they aren't serialized


      for (i = 0; i < atn.states.length; i++) {
        state = atn.states[i];

        for (j = 0; j < state.transitions.length; j++) {
          var t = state.transitions[j];

          if (!(t instanceof RuleTransition)) {
            continue;
          }

          var outermostPrecedenceReturn = -1;

          if (atn.ruleToStartState[t.target.ruleIndex].isPrecedenceRule) {
            if (t.precedence === 0) {
              outermostPrecedenceReturn = t.target.ruleIndex;
            }
          }

          trans = new EpsilonTransition(t.followState, outermostPrecedenceReturn);
          atn.ruleToStopState[t.target.ruleIndex].addTransition(trans);
        }
      }

      for (i = 0; i < atn.states.length; i++) {
        state = atn.states[i];

        if (state instanceof BlockStartState) {
          // we need to know the end state to set its start state
          if (state.endState === null) {
            throw "IllegalState";
          } // block end states can only be associated to a single block start
          // state


          if (state.endState.startState !== null) {
            throw "IllegalState";
          }

          state.endState.startState = state;
        }

        if (state instanceof PlusLoopbackState) {
          for (j = 0; j < state.transitions.length; j++) {
            target = state.transitions[j].target;

            if (target instanceof PlusBlockStartState) {
              target.loopBackState = state;
            }
          }
        } else if (state instanceof StarLoopbackState) {
          for (j = 0; j < state.transitions.length; j++) {
            target = state.transitions[j].target;

            if (target instanceof StarLoopEntryState) {
              target.loopBackState = state;
            }
          }
        }
      }
    };

    ATNDeserializer.prototype.readDecisions = function (atn) {
      var ndecisions = this.readInt();

      for (var i = 0; i < ndecisions; i++) {
        var s = this.readInt();
        var decState = atn.states[s];
        atn.decisionToState.push(decState);
        decState.decision = i;
      }
    };

    ATNDeserializer.prototype.readLexerActions = function (atn) {
      if (atn.grammarType === ATNType.LEXER) {
        var count = this.readInt();
        atn.lexerActions = initArray(count, null);

        for (var i = 0; i < count; i++) {
          var actionType = this.readInt();
          var data1 = this.readInt();

          if (data1 === 0xFFFF) {
            data1 = -1;
          }

          var data2 = this.readInt();

          if (data2 === 0xFFFF) {
            data2 = -1;
          }

          var lexerAction = this.lexerActionFactory(actionType, data1, data2);
          atn.lexerActions[i] = lexerAction;
        }
      }
    };

    ATNDeserializer.prototype.generateRuleBypassTransitions = function (atn) {
      var i;
      var count = atn.ruleToStartState.length;

      for (i = 0; i < count; i++) {
        atn.ruleToTokenType[i] = atn.maxTokenType + i + 1;
      }

      for (i = 0; i < count; i++) {
        this.generateRuleBypassTransition(atn, i);
      }
    };

    ATNDeserializer.prototype.generateRuleBypassTransition = function (atn, idx) {
      var i, state;
      var bypassStart = new BasicBlockStartState();
      bypassStart.ruleIndex = idx;
      atn.addState(bypassStart);
      var bypassStop = new BlockEndState();
      bypassStop.ruleIndex = idx;
      atn.addState(bypassStop);
      bypassStart.endState = bypassStop;
      atn.defineDecisionState(bypassStart);
      bypassStop.startState = bypassStart;
      var excludeTransition = null;
      var endState = null;

      if (atn.ruleToStartState[idx].isPrecedenceRule) {
        // wrap from the beginning of the rule to the StarLoopEntryState
        endState = null;

        for (i = 0; i < atn.states.length; i++) {
          state = atn.states[i];

          if (this.stateIsEndStateFor(state, idx)) {
            endState = state;
            excludeTransition = state.loopBackState.transitions[0];
            break;
          }
        }

        if (excludeTransition === null) {
          throw "Couldn't identify final state of the precedence rule prefix section.";
        }
      } else {
        endState = atn.ruleToStopState[idx];
      } // all non-excluded transitions that currently target end state need to
      // target blockEnd instead


      for (i = 0; i < atn.states.length; i++) {
        state = atn.states[i];

        for (var j = 0; j < state.transitions.length; j++) {
          var transition = state.transitions[j];

          if (transition === excludeTransition) {
            continue;
          }

          if (transition.target === endState) {
            transition.target = bypassStop;
          }
        }
      } // all transitions leaving the rule start state need to leave blockStart
      // instead


      var ruleToStartState = atn.ruleToStartState[idx];
      var count = ruleToStartState.transitions.length;

      while (count > 0) {
        bypassStart.addTransition(ruleToStartState.transitions[count - 1]);
        ruleToStartState.transitions = ruleToStartState.transitions.slice(-1);
      } // link the new states


      atn.ruleToStartState[idx].addTransition(new EpsilonTransition(bypassStart));
      bypassStop.addTransition(new EpsilonTransition(endState));
      var matchState = new BasicState();
      atn.addState(matchState);
      matchState.addTransition(new AtomTransition(bypassStop, atn.ruleToTokenType[idx]));
      bypassStart.addTransition(new EpsilonTransition(matchState));
    };

    ATNDeserializer.prototype.stateIsEndStateFor = function (state, idx) {
      if (state.ruleIndex !== idx) {
        return null;
      }

      if (!(state instanceof StarLoopEntryState)) {
        return null;
      }

      var maybeLoopEndState = state.transitions[state.transitions.length - 1].target;

      if (!(maybeLoopEndState instanceof LoopEndState)) {
        return null;
      }

      if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transitions[0].target instanceof RuleStopState) {
        return state;
      } else {
        return null;
      }
    }; //
    // Analyze the {@link StarLoopEntryState} states in the specified ATN to set
    // the {@link StarLoopEntryState//isPrecedenceDecision} field to the
    // correct value.
    //
    // @param atn The ATN.
    //


    ATNDeserializer.prototype.markPrecedenceDecisions = function (atn) {
      for (var i = 0; i < atn.states.length; i++) {
        var state = atn.states[i];

        if (!(state instanceof StarLoopEntryState)) {
          continue;
        } // We analyze the ATN to determine if this ATN decision state is the
        // decision for the closure block that determines whether a
        // precedence rule should continue or complete.
        //


        if (atn.ruleToStartState[state.ruleIndex].isPrecedenceRule) {
          var maybeLoopEndState = state.transitions[state.transitions.length - 1].target;

          if (maybeLoopEndState instanceof LoopEndState) {
            if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transitions[0].target instanceof RuleStopState) {
              state.isPrecedenceDecision = true;
            }
          }
        }
      }
    };

    ATNDeserializer.prototype.verifyATN = function (atn) {
      if (!this.deserializationOptions.verifyATN) {
        return;
      } // verify assumptions


      for (var i = 0; i < atn.states.length; i++) {
        var state = atn.states[i];

        if (state === null) {
          continue;
        }

        this.checkCondition(state.epsilonOnlyTransitions || state.transitions.length <= 1);

        if (state instanceof PlusBlockStartState) {
          this.checkCondition(state.loopBackState !== null);
        } else if (state instanceof StarLoopEntryState) {
          this.checkCondition(state.loopBackState !== null);
          this.checkCondition(state.transitions.length === 2);

          if (state.transitions[0].target instanceof StarBlockStartState) {
            this.checkCondition(state.transitions[1].target instanceof LoopEndState);
            this.checkCondition(!state.nonGreedy);
          } else if (state.transitions[0].target instanceof LoopEndState) {
            this.checkCondition(state.transitions[1].target instanceof StarBlockStartState);
            this.checkCondition(state.nonGreedy);
          } else {
            throw "IllegalState";
          }
        } else if (state instanceof StarLoopbackState) {
          this.checkCondition(state.transitions.length === 1);
          this.checkCondition(state.transitions[0].target instanceof StarLoopEntryState);
        } else if (state instanceof LoopEndState) {
          this.checkCondition(state.loopBackState !== null);
        } else if (state instanceof RuleStartState) {
          this.checkCondition(state.stopState !== null);
        } else if (state instanceof BlockStartState) {
          this.checkCondition(state.endState !== null);
        } else if (state instanceof BlockEndState) {
          this.checkCondition(state.startState !== null);
        } else if (state instanceof DecisionState) {
          this.checkCondition(state.transitions.length <= 1 || state.decision >= 0);
        } else {
          this.checkCondition(state.transitions.length <= 1 || state instanceof RuleStopState);
        }
      }
    };

    ATNDeserializer.prototype.checkCondition = function (condition, message) {
      if (!condition) {
        if (message === undefined || message === null) {
          message = "IllegalState";
        }

        throw message;
      }
    };

    ATNDeserializer.prototype.readInt = function () {
      return this.data[this.pos++];
    };

    ATNDeserializer.prototype.readInt32 = function () {
      var low = this.readInt();
      var high = this.readInt();
      return low | high << 16;
    };

    ATNDeserializer.prototype.readLong = function () {
      var low = this.readInt32();
      var high = this.readInt32();
      return low & 0x00000000FFFFFFFF | high << 32;
    };

    function createByteToHex() {
      var bth = [];

      for (var i = 0; i < 256; i++) {
        bth[i] = (i + 0x100).toString(16).substr(1).toUpperCase();
      }

      return bth;
    }

    var byteToHex = createByteToHex();

    ATNDeserializer.prototype.readUUID = function () {
      var bb = [];

      for (var i = 7; i >= 0; i--) {
        var _int = this.readInt();
        /* jshint bitwise: false */


        bb[2 * i + 1] = _int & 0xFF;
        bb[2 * i] = _int >> 8 & 0xFF;
      }

      return byteToHex[bb[0]] + byteToHex[bb[1]] + byteToHex[bb[2]] + byteToHex[bb[3]] + '-' + byteToHex[bb[4]] + byteToHex[bb[5]] + '-' + byteToHex[bb[6]] + byteToHex[bb[7]] + '-' + byteToHex[bb[8]] + byteToHex[bb[9]] + '-' + byteToHex[bb[10]] + byteToHex[bb[11]] + byteToHex[bb[12]] + byteToHex[bb[13]] + byteToHex[bb[14]] + byteToHex[bb[15]];
    };

    ATNDeserializer.prototype.edgeFactory = function (atn, type, src, trg, arg1, arg2, arg3, sets) {
      var target = atn.states[trg];

      switch (type) {
        case Transition.EPSILON:
          return new EpsilonTransition(target);

        case Transition.RANGE:
          return arg3 !== 0 ? new RangeTransition(target, Token.EOF, arg2) : new RangeTransition(target, arg1, arg2);

        case Transition.RULE:
          return new RuleTransition(atn.states[arg1], arg2, arg3, target);

        case Transition.PREDICATE:
          return new PredicateTransition(target, arg1, arg2, arg3 !== 0);

        case Transition.PRECEDENCE:
          return new PrecedencePredicateTransition(target, arg1);

        case Transition.ATOM:
          return arg3 !== 0 ? new AtomTransition(target, Token.EOF) : new AtomTransition(target, arg1);

        case Transition.ACTION:
          return new ActionTransition(target, arg1, arg2, arg3 !== 0);

        case Transition.SET:
          return new SetTransition(target, sets[arg1]);

        case Transition.NOT_SET:
          return new NotSetTransition(target, sets[arg1]);

        case Transition.WILDCARD:
          return new WildcardTransition(target);

        default:
          throw "The specified transition type: " + type + " is not valid.";
      }
    };

    ATNDeserializer.prototype.stateFactory = function (type, ruleIndex) {
      if (this.stateFactories === null) {
        var sf = [];
        sf[ATNState.INVALID_TYPE] = null;

        sf[ATNState.BASIC] = function () {
          return new BasicState();
        };

        sf[ATNState.RULE_START] = function () {
          return new RuleStartState();
        };

        sf[ATNState.BLOCK_START] = function () {
          return new BasicBlockStartState();
        };

        sf[ATNState.PLUS_BLOCK_START] = function () {
          return new PlusBlockStartState();
        };

        sf[ATNState.STAR_BLOCK_START] = function () {
          return new StarBlockStartState();
        };

        sf[ATNState.TOKEN_START] = function () {
          return new TokensStartState();
        };

        sf[ATNState.RULE_STOP] = function () {
          return new RuleStopState();
        };

        sf[ATNState.BLOCK_END] = function () {
          return new BlockEndState();
        };

        sf[ATNState.STAR_LOOP_BACK] = function () {
          return new StarLoopbackState();
        };

        sf[ATNState.STAR_LOOP_ENTRY] = function () {
          return new StarLoopEntryState();
        };

        sf[ATNState.PLUS_LOOP_BACK] = function () {
          return new PlusLoopbackState();
        };

        sf[ATNState.LOOP_END] = function () {
          return new LoopEndState();
        };

        this.stateFactories = sf;
      }

      if (type > this.stateFactories.length || this.stateFactories[type] === null) {
        throw "The specified state type " + type + " is not valid.";
      } else {
        var s = this.stateFactories[type]();

        if (s !== null) {
          s.ruleIndex = ruleIndex;
          return s;
        }
      }
    };

    ATNDeserializer.prototype.lexerActionFactory = function (type, data1, data2) {
      if (this.actionFactories === null) {
        var af = [];

        af[LexerActionType.CHANNEL] = function (data1, data2) {
          return new LexerChannelAction(data1);
        };

        af[LexerActionType.CUSTOM] = function (data1, data2) {
          return new LexerCustomAction(data1, data2);
        };

        af[LexerActionType.MODE] = function (data1, data2) {
          return new LexerModeAction(data1);
        };

        af[LexerActionType.MORE] = function (data1, data2) {
          return LexerMoreAction.INSTANCE;
        };

        af[LexerActionType.POP_MODE] = function (data1, data2) {
          return LexerPopModeAction.INSTANCE;
        };

        af[LexerActionType.PUSH_MODE] = function (data1, data2) {
          return new LexerPushModeAction(data1);
        };

        af[LexerActionType.SKIP] = function (data1, data2) {
          return LexerSkipAction.INSTANCE;
        };

        af[LexerActionType.TYPE] = function (data1, data2) {
          return new LexerTypeAction(data1);
        };

        this.actionFactories = af;
      }

      if (type > this.actionFactories.length || this.actionFactories[type] === null) {
        throw "The specified lexer action type " + type + " is not valid.";
      } else {
        return this.actionFactories[type](data1, data2);
      }
    };

    exports.ATNDeserializer = ATNDeserializer;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/ATNSimulator.js":
  /*!*************************************************!*\
    !*** ./node_modules/antlr4/atn/ATNSimulator.js ***!
    \*************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_ATNSimulatorJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    var DFAState = __webpack_require__(
    /*! ./../dfa/DFAState */
    "./node_modules/antlr4/dfa/DFAState.js").DFAState;

    var ATNConfigSet = __webpack_require__(
    /*! ./ATNConfigSet */
    "./node_modules/antlr4/atn/ATNConfigSet.js").ATNConfigSet;

    var getCachedPredictionContext = __webpack_require__(
    /*! ./../PredictionContext */
    "./node_modules/antlr4/PredictionContext.js").getCachedPredictionContext;

    function ATNSimulator(atn, sharedContextCache) {
      // The context cache maps all PredictionContext objects that are ==
      //  to a single cached copy. This cache is shared across all contexts
      //  in all ATNConfigs in all DFA states.  We rebuild each ATNConfigSet
      //  to use only cached nodes/graphs in addDFAState(). We don't want to
      //  fill this during closure() since there are lots of contexts that
      //  pop up but are not used ever again. It also greatly slows down closure().
      //
      //  <p>This cache makes a huge difference in memory and a little bit in speed.
      //  For the Java grammar on java.*, it dropped the memory requirements
      //  at the end from 25M to 16M. We don't store any of the full context
      //  graphs in the DFA because they are limited to local context only,
      //  but apparently there's a lot of repetition there as well. We optimize
      //  the config contexts before storing the config set in the DFA states
      //  by literally rebuilding them with cached subgraphs only.</p>
      //
      //  <p>I tried a cache for use during closure operations, that was
      //  whacked after each adaptivePredict(). It cost a little bit
      //  more time I think and doesn't save on the overall footprint
      //  so it's not worth the complexity.</p>
      ///
      this.atn = atn;
      this.sharedContextCache = sharedContextCache;
      return this;
    } // Must distinguish between missing edge and edge we know leads nowhere///


    ATNSimulator.ERROR = new DFAState(0x7FFFFFFF, new ATNConfigSet());

    ATNSimulator.prototype.getCachedContext = function (context) {
      if (this.sharedContextCache === null) {
        return context;
      }

      var visited = {};
      return getCachedPredictionContext(context, this.sharedContextCache, visited);
    };

    exports.ATNSimulator = ATNSimulator;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/ATNState.js":
  /*!*********************************************!*\
    !*** ./node_modules/antlr4/atn/ATNState.js ***!
    \*********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_ATNStateJs(module, exports) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    // The following images show the relation of states and
    // {@link ATNState//transitions} for various grammar constructs.
    //
    // <ul>
    //
    // <li>Solid edges marked with an &//0949; indicate a required
    // {@link EpsilonTransition}.</li>
    //
    // <li>Dashed edges indicate locations where any transition derived from
    // {@link Transition} might appear.</li>
    //
    // <li>Dashed nodes are place holders for either a sequence of linked
    // {@link BasicState} states or the inclusion of a block representing a nested
    // construct in one of the forms below.</li>
    //
    // <li>Nodes showing multiple outgoing alternatives with a {@code ...} support
    // any number of alternatives (one or more). Nodes without the {@code ...} only
    // support the exact number of alternatives shown in the diagram.</li>
    //
    // </ul>
    //
    // <h2>Basic Blocks</h2>
    //
    // <h3>Rule</h3>
    //
    // <embed src="images/Rule.svg" type="image/svg+xml"/>
    //
    // <h3>Block of 1 or more alternatives</h3>
    //
    // <embed src="images/Block.svg" type="image/svg+xml"/>
    //
    // <h2>Greedy Loops</h2>
    //
    // <h3>Greedy Closure: {@code (...)*}</h3>
    //
    // <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
    //
    // <h3>Greedy Positive Closure: {@code (...)+}</h3>
    //
    // <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
    //
    // <h3>Greedy Optional: {@code (...)?}</h3>
    //
    // <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
    //
    // <h2>Non-Greedy Loops</h2>
    //
    // <h3>Non-Greedy Closure: {@code (...)*?}</h3>
    //
    // <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
    //
    // <h3>Non-Greedy Positive Closure: {@code (...)+?}</h3>
    //
    // <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
    //
    // <h3>Non-Greedy Optional: {@code (...)??}</h3>
    //
    // <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
    //
    var INITIAL_NUM_TRANSITIONS = 4;

    function ATNState() {
      // Which ATN are we in?
      this.atn = null;
      this.stateNumber = ATNState.INVALID_STATE_NUMBER;
      this.stateType = null;
      this.ruleIndex = 0; // at runtime, we don't have Rule objects

      this.epsilonOnlyTransitions = false; // Track the transitions emanating from this ATN state.

      this.transitions = []; // Used to cache lookahead during parsing, not used during construction

      this.nextTokenWithinRule = null;
      return this;
    } // constants for serialization


    ATNState.INVALID_TYPE = 0;
    ATNState.BASIC = 1;
    ATNState.RULE_START = 2;
    ATNState.BLOCK_START = 3;
    ATNState.PLUS_BLOCK_START = 4;
    ATNState.STAR_BLOCK_START = 5;
    ATNState.TOKEN_START = 6;
    ATNState.RULE_STOP = 7;
    ATNState.BLOCK_END = 8;
    ATNState.STAR_LOOP_BACK = 9;
    ATNState.STAR_LOOP_ENTRY = 10;
    ATNState.PLUS_LOOP_BACK = 11;
    ATNState.LOOP_END = 12;
    ATNState.serializationNames = ["INVALID", "BASIC", "RULE_START", "BLOCK_START", "PLUS_BLOCK_START", "STAR_BLOCK_START", "TOKEN_START", "RULE_STOP", "BLOCK_END", "STAR_LOOP_BACK", "STAR_LOOP_ENTRY", "PLUS_LOOP_BACK", "LOOP_END"];
    ATNState.INVALID_STATE_NUMBER = -1;

    ATNState.prototype.toString = function () {
      return this.stateNumber;
    };

    ATNState.prototype.equals = function (other) {
      if (other instanceof ATNState) {
        return this.stateNumber === other.stateNumber;
      } else {
        return false;
      }
    };

    ATNState.prototype.isNonGreedyExitState = function () {
      return false;
    };

    ATNState.prototype.addTransition = function (trans, index) {
      if (index === undefined) {
        index = -1;
      }

      if (this.transitions.length === 0) {
        this.epsilonOnlyTransitions = trans.isEpsilon;
      } else if (this.epsilonOnlyTransitions !== trans.isEpsilon) {
        this.epsilonOnlyTransitions = false;
      }

      if (index === -1) {
        this.transitions.push(trans);
      } else {
        this.transitions.splice(index, 1, trans);
      }
    };

    function BasicState() {
      ATNState.call(this);
      this.stateType = ATNState.BASIC;
      return this;
    }

    BasicState.prototype = Object.create(ATNState.prototype);
    BasicState.prototype.constructor = BasicState;

    function DecisionState() {
      ATNState.call(this);
      this.decision = -1;
      this.nonGreedy = false;
      return this;
    }

    DecisionState.prototype = Object.create(ATNState.prototype);
    DecisionState.prototype.constructor = DecisionState; //  The start of a regular {@code (...)} block.

    function BlockStartState() {
      DecisionState.call(this);
      this.endState = null;
      return this;
    }

    BlockStartState.prototype = Object.create(DecisionState.prototype);
    BlockStartState.prototype.constructor = BlockStartState;

    function BasicBlockStartState() {
      BlockStartState.call(this);
      this.stateType = ATNState.BLOCK_START;
      return this;
    }

    BasicBlockStartState.prototype = Object.create(BlockStartState.prototype);
    BasicBlockStartState.prototype.constructor = BasicBlockStartState; // Terminal node of a simple {@code (a|b|c)} block.

    function BlockEndState() {
      ATNState.call(this);
      this.stateType = ATNState.BLOCK_END;
      this.startState = null;
      return this;
    }

    BlockEndState.prototype = Object.create(ATNState.prototype);
    BlockEndState.prototype.constructor = BlockEndState; // The last node in the ATN for a rule, unless that rule is the start symbol.
    //  In that case, there is one transition to EOF. Later, we might encode
    //  references to all calls to this rule to compute FOLLOW sets for
    //  error handling.
    //

    function RuleStopState() {
      ATNState.call(this);
      this.stateType = ATNState.RULE_STOP;
      return this;
    }

    RuleStopState.prototype = Object.create(ATNState.prototype);
    RuleStopState.prototype.constructor = RuleStopState;

    function RuleStartState() {
      ATNState.call(this);
      this.stateType = ATNState.RULE_START;
      this.stopState = null;
      this.isPrecedenceRule = false;
      return this;
    }

    RuleStartState.prototype = Object.create(ATNState.prototype);
    RuleStartState.prototype.constructor = RuleStartState; // Decision state for {@code A+} and {@code (A|B)+}.  It has two transitions:
    //  one to the loop back to start of the block and one to exit.
    //

    function PlusLoopbackState() {
      DecisionState.call(this);
      this.stateType = ATNState.PLUS_LOOP_BACK;
      return this;
    }

    PlusLoopbackState.prototype = Object.create(DecisionState.prototype);
    PlusLoopbackState.prototype.constructor = PlusLoopbackState; // Start of {@code (A|B|...)+} loop. Technically a decision state, but
    //  we don't use for code generation; somebody might need it, so I'm defining
    //  it for completeness. In reality, the {@link PlusLoopbackState} node is the
    //  real decision-making note for {@code A+}.
    //

    function PlusBlockStartState() {
      BlockStartState.call(this);
      this.stateType = ATNState.PLUS_BLOCK_START;
      this.loopBackState = null;
      return this;
    }

    PlusBlockStartState.prototype = Object.create(BlockStartState.prototype);
    PlusBlockStartState.prototype.constructor = PlusBlockStartState; // The block that begins a closure loop.

    function StarBlockStartState() {
      BlockStartState.call(this);
      this.stateType = ATNState.STAR_BLOCK_START;
      return this;
    }

    StarBlockStartState.prototype = Object.create(BlockStartState.prototype);
    StarBlockStartState.prototype.constructor = StarBlockStartState;

    function StarLoopbackState() {
      ATNState.call(this);
      this.stateType = ATNState.STAR_LOOP_BACK;
      return this;
    }

    StarLoopbackState.prototype = Object.create(ATNState.prototype);
    StarLoopbackState.prototype.constructor = StarLoopbackState;

    function StarLoopEntryState() {
      DecisionState.call(this);
      this.stateType = ATNState.STAR_LOOP_ENTRY;
      this.loopBackState = null; // Indicates whether this state can benefit from a precedence DFA during SLL decision making.

      this.isPrecedenceDecision = null;
      return this;
    }

    StarLoopEntryState.prototype = Object.create(DecisionState.prototype);
    StarLoopEntryState.prototype.constructor = StarLoopEntryState; // Mark the end of a * or + loop.

    function LoopEndState() {
      ATNState.call(this);
      this.stateType = ATNState.LOOP_END;
      this.loopBackState = null;
      return this;
    }

    LoopEndState.prototype = Object.create(ATNState.prototype);
    LoopEndState.prototype.constructor = LoopEndState; // The Tokens rule start state linking to each lexer rule start state */

    function TokensStartState() {
      DecisionState.call(this);
      this.stateType = ATNState.TOKEN_START;
      return this;
    }

    TokensStartState.prototype = Object.create(DecisionState.prototype);
    TokensStartState.prototype.constructor = TokensStartState;
    exports.ATNState = ATNState;
    exports.BasicState = BasicState;
    exports.DecisionState = DecisionState;
    exports.BlockStartState = BlockStartState;
    exports.BlockEndState = BlockEndState;
    exports.LoopEndState = LoopEndState;
    exports.RuleStartState = RuleStartState;
    exports.RuleStopState = RuleStopState;
    exports.TokensStartState = TokensStartState;
    exports.PlusLoopbackState = PlusLoopbackState;
    exports.StarLoopbackState = StarLoopbackState;
    exports.StarLoopEntryState = StarLoopEntryState;
    exports.PlusBlockStartState = PlusBlockStartState;
    exports.StarBlockStartState = StarBlockStartState;
    exports.BasicBlockStartState = BasicBlockStartState;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/ATNType.js":
  /*!********************************************!*\
    !*** ./node_modules/antlr4/atn/ATNType.js ***!
    \********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_ATNTypeJs(module, exports) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    // Represents the type of recognizer an ATN applies to.
    function ATNType() {}

    ATNType.LEXER = 0;
    ATNType.PARSER = 1;
    exports.ATNType = ATNType;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/LexerATNSimulator.js":
  /*!******************************************************!*\
    !*** ./node_modules/antlr4/atn/LexerATNSimulator.js ***!
    \******************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_LexerATNSimulatorJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    // When we hit an accept state in either the DFA or the ATN, we
    //  have to notify the character stream to start buffering characters
    //  via {@link IntStream//mark} and record the current state. The current sim state
    //  includes the current index into the input, the current line,
    //  and current character position in that line. Note that the Lexer is
    //  tracking the starting line and characterization of the token. These
    //  variables track the "state" of the simulator when it hits an accept state.
    //
    //  <p>We track these variables separately for the DFA and ATN simulation
    //  because the DFA simulation often has to fail over to the ATN
    //  simulation. If the ATN simulation fails, we need the DFA to fall
    //  back to its previously accepted state, if any. If the ATN succeeds,
    //  then the ATN does the accept and the DFA simulator that invoked it
    //  can simply return the predicted token type.</p>
    ///
    var Token = __webpack_require__(
    /*! ./../Token */
    "./node_modules/antlr4/Token.js").Token;

    var Lexer = __webpack_require__(
    /*! ./../Lexer */
    "./node_modules/antlr4/Lexer.js").Lexer;

    var ATN = __webpack_require__(
    /*! ./ATN */
    "./node_modules/antlr4/atn/ATN.js").ATN;

    var ATNSimulator = __webpack_require__(
    /*! ./ATNSimulator */
    "./node_modules/antlr4/atn/ATNSimulator.js").ATNSimulator;

    var DFAState = __webpack_require__(
    /*! ./../dfa/DFAState */
    "./node_modules/antlr4/dfa/DFAState.js").DFAState;

    var ATNConfigSet = __webpack_require__(
    /*! ./ATNConfigSet */
    "./node_modules/antlr4/atn/ATNConfigSet.js").ATNConfigSet;

    var OrderedATNConfigSet = __webpack_require__(
    /*! ./ATNConfigSet */
    "./node_modules/antlr4/atn/ATNConfigSet.js").OrderedATNConfigSet;

    var PredictionContext = __webpack_require__(
    /*! ./../PredictionContext */
    "./node_modules/antlr4/PredictionContext.js").PredictionContext;

    var SingletonPredictionContext = __webpack_require__(
    /*! ./../PredictionContext */
    "./node_modules/antlr4/PredictionContext.js").SingletonPredictionContext;

    var RuleStopState = __webpack_require__(
    /*! ./ATNState */
    "./node_modules/antlr4/atn/ATNState.js").RuleStopState;

    var LexerATNConfig = __webpack_require__(
    /*! ./ATNConfig */
    "./node_modules/antlr4/atn/ATNConfig.js").LexerATNConfig;

    var Transition = __webpack_require__(
    /*! ./Transition */
    "./node_modules/antlr4/atn/Transition.js").Transition;

    var LexerActionExecutor = __webpack_require__(
    /*! ./LexerActionExecutor */
    "./node_modules/antlr4/atn/LexerActionExecutor.js").LexerActionExecutor;

    var LexerNoViableAltException = __webpack_require__(
    /*! ./../error/Errors */
    "./node_modules/antlr4/error/Errors.js").LexerNoViableAltException;

    function resetSimState(sim) {
      sim.index = -1;
      sim.line = 0;
      sim.column = -1;
      sim.dfaState = null;
    }

    function SimState() {
      resetSimState(this);
      return this;
    }

    SimState.prototype.reset = function () {
      resetSimState(this);
    };

    function LexerATNSimulator(recog, atn, decisionToDFA, sharedContextCache) {
      ATNSimulator.call(this, atn, sharedContextCache);
      this.decisionToDFA = decisionToDFA;
      this.recog = recog; // The current token's starting index into the character stream.
      // Shared across DFA to ATN simulation in case the ATN fails and the
      // DFA did not have a previous accept state. In this case, we use the
      // ATN-generated exception object.

      this.startIndex = -1; // line number 1..n within the input///

      this.line = 1; // The index of the character relative to the beginning of the line
      // 0..n-1///

      this.column = 0;
      this.mode = Lexer.DEFAULT_MODE; // Used during DFA/ATN exec to record the most recent accept configuration
      // info

      this.prevAccept = new SimState(); // done

      return this;
    }

    LexerATNSimulator.prototype = Object.create(ATNSimulator.prototype);
    LexerATNSimulator.prototype.constructor = LexerATNSimulator;
    LexerATNSimulator.debug = false;
    LexerATNSimulator.dfa_debug = false;
    LexerATNSimulator.MIN_DFA_EDGE = 0;
    LexerATNSimulator.MAX_DFA_EDGE = 127; // forces unicode to stay in ATN

    LexerATNSimulator.match_calls = 0;

    LexerATNSimulator.prototype.copyState = function (simulator) {
      this.column = simulator.column;
      this.line = simulator.line;
      this.mode = simulator.mode;
      this.startIndex = simulator.startIndex;
    };

    LexerATNSimulator.prototype.match = function (input, mode) {
      this.match_calls += 1;
      this.mode = mode;
      var mark = input.mark();

      try {
        this.startIndex = input.index;
        this.prevAccept.reset();
        var dfa = this.decisionToDFA[mode];

        if (dfa.s0 === null) {
          return this.matchATN(input);
        } else {
          return this.execATN(input, dfa.s0);
        }
      } finally {
        input.release(mark);
      }
    };

    LexerATNSimulator.prototype.reset = function () {
      this.prevAccept.reset();
      this.startIndex = -1;
      this.line = 1;
      this.column = 0;
      this.mode = Lexer.DEFAULT_MODE;
    };

    LexerATNSimulator.prototype.matchATN = function (input) {
      var startState = this.atn.modeToStartState[this.mode];

      if (LexerATNSimulator.debug) {
        console.log("matchATN mode " + this.mode + " start: " + startState);
      }

      var old_mode = this.mode;
      var s0_closure = this.computeStartState(input, startState);
      var suppressEdge = s0_closure.hasSemanticContext;
      s0_closure.hasSemanticContext = false;
      var next = this.addDFAState(s0_closure);

      if (!suppressEdge) {
        this.decisionToDFA[this.mode].s0 = next;
      }

      var predict = this.execATN(input, next);

      if (LexerATNSimulator.debug) {
        console.log("DFA after matchATN: " + this.decisionToDFA[old_mode].toLexerString());
      }

      return predict;
    };

    LexerATNSimulator.prototype.execATN = function (input, ds0) {
      if (LexerATNSimulator.debug) {
        console.log("start state closure=" + ds0.configs);
      }

      if (ds0.isAcceptState) {
        // allow zero-length tokens
        this.captureSimState(this.prevAccept, input, ds0);
      }

      var t = input.LA(1);
      var s = ds0; // s is current/from DFA state

      while (true) {
        // while more work
        if (LexerATNSimulator.debug) {
          console.log("execATN loop starting closure: " + s.configs);
        } // As we move src->trg, src->trg, we keep track of the previous trg to
        // avoid looking up the DFA state again, which is expensive.
        // If the previous target was already part of the DFA, we might
        // be able to avoid doing a reach operation upon t. If s!=null,
        // it means that semantic predicates didn't prevent us from
        // creating a DFA state. Once we know s!=null, we check to see if
        // the DFA state has an edge already for t. If so, we can just reuse
        // it's configuration set; there's no point in re-computing it.
        // This is kind of like doing DFA simulation within the ATN
        // simulation because DFA simulation is really just a way to avoid
        // computing reach/closure sets. Technically, once we know that
        // we have a previously added DFA state, we could jump over to
        // the DFA simulator. But, that would mean popping back and forth
        // a lot and making things more complicated algorithmically.
        // This optimization makes a lot of sense for loops within DFA.
        // A character will take us back to an existing DFA state
        // that already has lots of edges out of it. e.g., .* in comments.
        // print("Target for:" + str(s) + " and:" + str(t))


        var target = this.getExistingTargetState(s, t); // print("Existing:" + str(target))

        if (target === null) {
          target = this.computeTargetState(input, s, t); // print("Computed:" + str(target))
        }

        if (target === ATNSimulator.ERROR) {
          break;
        } // If this is a consumable input element, make sure to consume before
        // capturing the accept state so the input index, line, and char
        // position accurately reflect the state of the interpreter at the
        // end of the token.


        if (t !== Token.EOF) {
          this.consume(input);
        }

        if (target.isAcceptState) {
          this.captureSimState(this.prevAccept, input, target);

          if (t === Token.EOF) {
            break;
          }
        }

        t = input.LA(1);
        s = target; // flip; current DFA target becomes new src/from state
      }

      return this.failOrAccept(this.prevAccept, input, s.configs, t);
    }; // Get an existing target state for an edge in the DFA. If the target state
    // for the edge has not yet been computed or is otherwise not available,
    // this method returns {@code null}.
    //
    // @param s The current DFA state
    // @param t The next input symbol
    // @return The existing target DFA state for the given input symbol
    // {@code t}, or {@code null} if the target state for this edge is not
    // already cached


    LexerATNSimulator.prototype.getExistingTargetState = function (s, t) {
      if (s.edges === null || t < LexerATNSimulator.MIN_DFA_EDGE || t > LexerATNSimulator.MAX_DFA_EDGE) {
        return null;
      }

      var target = s.edges[t - LexerATNSimulator.MIN_DFA_EDGE];

      if (target === undefined) {
        target = null;
      }

      if (LexerATNSimulator.debug && target !== null) {
        console.log("reuse state " + s.stateNumber + " edge to " + target.stateNumber);
      }

      return target;
    }; // Compute a target state for an edge in the DFA, and attempt to add the
    // computed state and corresponding edge to the DFA.
    //
    // @param input The input stream
    // @param s The current DFA state
    // @param t The next input symbol
    //
    // @return The computed target DFA state for the given input symbol
    // {@code t}. If {@code t} does not lead to a valid DFA state, this method
    // returns {@link //ERROR}.


    LexerATNSimulator.prototype.computeTargetState = function (input, s, t) {
      var reach = new OrderedATNConfigSet(); // if we don't find an existing DFA state
      // Fill reach starting from closure, following t transitions

      this.getReachableConfigSet(input, s.configs, reach, t);

      if (reach.items.length === 0) {
        // we got nowhere on t from s
        if (!reach.hasSemanticContext) {
          // we got nowhere on t, don't throw out this knowledge; it'd
          // cause a failover from DFA later.
          this.addDFAEdge(s, t, ATNSimulator.ERROR);
        } // stop when we can't match any more char


        return ATNSimulator.ERROR;
      } // Add an edge from s to target DFA found/created for reach


      return this.addDFAEdge(s, t, null, reach);
    };

    LexerATNSimulator.prototype.failOrAccept = function (prevAccept, input, reach, t) {
      if (this.prevAccept.dfaState !== null) {
        var lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor;
        this.accept(input, lexerActionExecutor, this.startIndex, prevAccept.index, prevAccept.line, prevAccept.column);
        return prevAccept.dfaState.prediction;
      } else {
        // if no accept and EOF is first char, return EOF
        if (t === Token.EOF && input.index === this.startIndex) {
          return Token.EOF;
        }

        throw new LexerNoViableAltException(this.recog, input, this.startIndex, reach);
      }
    }; // Given a starting configuration set, figure out all ATN configurations
    // we can reach upon input {@code t}. Parameter {@code reach} is a return
    // parameter.


    LexerATNSimulator.prototype.getReachableConfigSet = function (input, closure, reach, t) {
      // this is used to skip processing for configs which have a lower priority
      // than a config that already reached an accept state for the same rule
      var skipAlt = ATN.INVALID_ALT_NUMBER;

      for (var i = 0; i < closure.items.length; i++) {
        var cfg = closure.items[i];
        var currentAltReachedAcceptState = cfg.alt === skipAlt;

        if (currentAltReachedAcceptState && cfg.passedThroughNonGreedyDecision) {
          continue;
        }

        if (LexerATNSimulator.debug) {
          console.log("testing %s at %s\n", this.getTokenName(t), cfg.toString(this.recog, true));
        }

        for (var j = 0; j < cfg.state.transitions.length; j++) {
          var trans = cfg.state.transitions[j]; // for each transition

          var target = this.getReachableTarget(trans, t);

          if (target !== null) {
            var lexerActionExecutor = cfg.lexerActionExecutor;

            if (lexerActionExecutor !== null) {
              lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - this.startIndex);
            }

            var treatEofAsEpsilon = t === Token.EOF;
            var config = new LexerATNConfig({
              state: target,
              lexerActionExecutor: lexerActionExecutor
            }, cfg);

            if (this.closure(input, config, reach, currentAltReachedAcceptState, true, treatEofAsEpsilon)) {
              // any remaining configs for this alt have a lower priority
              // than the one that just reached an accept state.
              skipAlt = cfg.alt;
            }
          }
        }
      }
    };

    LexerATNSimulator.prototype.accept = function (input, lexerActionExecutor, startIndex, index, line, charPos) {
      if (LexerATNSimulator.debug) {
        console.log("ACTION %s\n", lexerActionExecutor);
      } // seek to after last char in token


      input.seek(index);
      this.line = line;
      this.column = charPos;

      if (lexerActionExecutor !== null && this.recog !== null) {
        lexerActionExecutor.execute(this.recog, input, startIndex);
      }
    };

    LexerATNSimulator.prototype.getReachableTarget = function (trans, t) {
      if (trans.matches(t, 0, Lexer.MAX_CHAR_VALUE)) {
        return trans.target;
      } else {
        return null;
      }
    };

    LexerATNSimulator.prototype.computeStartState = function (input, p) {
      var initialContext = PredictionContext.EMPTY;
      var configs = new OrderedATNConfigSet();

      for (var i = 0; i < p.transitions.length; i++) {
        var target = p.transitions[i].target;
        var cfg = new LexerATNConfig({
          state: target,
          alt: i + 1,
          context: initialContext
        }, null);
        this.closure(input, cfg, configs, false, false, false);
      }

      return configs;
    }; // Since the alternatives within any lexer decision are ordered by
    // preference, this method stops pursuing the closure as soon as an accept
    // state is reached. After the first accept state is reached by depth-first
    // search from {@code config}, all other (potentially reachable) states for
    // this rule would have a lower priority.
    //
    // @return {@code true} if an accept state is reached, otherwise
    // {@code false}.


    LexerATNSimulator.prototype.closure = function (input, config, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon) {
      var cfg = null;

      if (LexerATNSimulator.debug) {
        console.log("closure(" + config.toString(this.recog, true) + ")");
      }

      if (config.state instanceof RuleStopState) {
        if (LexerATNSimulator.debug) {
          if (this.recog !== null) {
            console.log("closure at %s rule stop %s\n", this.recog.ruleNames[config.state.ruleIndex], config);
          } else {
            console.log("closure at rule stop %s\n", config);
          }
        }

        if (config.context === null || config.context.hasEmptyPath()) {
          if (config.context === null || config.context.isEmpty()) {
            configs.add(config);
            return true;
          } else {
            configs.add(new LexerATNConfig({
              state: config.state,
              context: PredictionContext.EMPTY
            }, config));
            currentAltReachedAcceptState = true;
          }
        }

        if (config.context !== null && !config.context.isEmpty()) {
          for (var i = 0; i < config.context.length; i++) {
            if (config.context.getReturnState(i) !== PredictionContext.EMPTY_RETURN_STATE) {
              var newContext = config.context.getParent(i); // "pop" return state

              var returnState = this.atn.states[config.context.getReturnState(i)];
              cfg = new LexerATNConfig({
                state: returnState,
                context: newContext
              }, config);
              currentAltReachedAcceptState = this.closure(input, cfg, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon);
            }
          }
        }

        return currentAltReachedAcceptState;
      } // optimization


      if (!config.state.epsilonOnlyTransitions) {
        if (!currentAltReachedAcceptState || !config.passedThroughNonGreedyDecision) {
          configs.add(config);
        }
      }

      for (var j = 0; j < config.state.transitions.length; j++) {
        var trans = config.state.transitions[j];
        cfg = this.getEpsilonTarget(input, config, trans, configs, speculative, treatEofAsEpsilon);

        if (cfg !== null) {
          currentAltReachedAcceptState = this.closure(input, cfg, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon);
        }
      }

      return currentAltReachedAcceptState;
    }; // side-effect: can alter configs.hasSemanticContext


    LexerATNSimulator.prototype.getEpsilonTarget = function (input, config, trans, configs, speculative, treatEofAsEpsilon) {
      var cfg = null;

      if (trans.serializationType === Transition.RULE) {
        var newContext = SingletonPredictionContext.create(config.context, trans.followState.stateNumber);
        cfg = new LexerATNConfig({
          state: trans.target,
          context: newContext
        }, config);
      } else if (trans.serializationType === Transition.PRECEDENCE) {
        throw "Precedence predicates are not supported in lexers.";
      } else if (trans.serializationType === Transition.PREDICATE) {
        // Track traversing semantic predicates. If we traverse,
        // we cannot add a DFA state for this "reach" computation
        // because the DFA would not test the predicate again in the
        // future. Rather than creating collections of semantic predicates
        // like v3 and testing them on prediction, v4 will test them on the
        // fly all the time using the ATN not the DFA. This is slower but
        // semantically it's not used that often. One of the key elements to
        // this predicate mechanism is not adding DFA states that see
        // predicates immediately afterwards in the ATN. For example,
        // a : ID {p1}? | ID {p2}? ;
        // should create the start state for rule 'a' (to save start state
        // competition), but should not create target of ID state. The
        // collection of ATN states the following ID references includes
        // states reached by traversing predicates. Since this is when we
        // test them, we cannot cash the DFA state target of ID.
        if (LexerATNSimulator.debug) {
          console.log("EVAL rule " + trans.ruleIndex + ":" + trans.predIndex);
        }

        configs.hasSemanticContext = true;

        if (this.evaluatePredicate(input, trans.ruleIndex, trans.predIndex, speculative)) {
          cfg = new LexerATNConfig({
            state: trans.target
          }, config);
        }
      } else if (trans.serializationType === Transition.ACTION) {
        if (config.context === null || config.context.hasEmptyPath()) {
          // execute actions anywhere in the start rule for a token.
          //
          // TODO: if the entry rule is invoked recursively, some
          // actions may be executed during the recursive call. The
          // problem can appear when hasEmptyPath() is true but
          // isEmpty() is false. In this case, the config needs to be
          // split into two contexts - one with just the empty path
          // and another with everything but the empty path.
          // Unfortunately, the current algorithm does not allow
          // getEpsilonTarget to return two configurations, so
          // additional modifications are needed before we can support
          // the split operation.
          var lexerActionExecutor = LexerActionExecutor.append(config.lexerActionExecutor, this.atn.lexerActions[trans.actionIndex]);
          cfg = new LexerATNConfig({
            state: trans.target,
            lexerActionExecutor: lexerActionExecutor
          }, config);
        } else {
          // ignore actions in referenced rules
          cfg = new LexerATNConfig({
            state: trans.target
          }, config);
        }
      } else if (trans.serializationType === Transition.EPSILON) {
        cfg = new LexerATNConfig({
          state: trans.target
        }, config);
      } else if (trans.serializationType === Transition.ATOM || trans.serializationType === Transition.RANGE || trans.serializationType === Transition.SET) {
        if (treatEofAsEpsilon) {
          if (trans.matches(Token.EOF, 0, Lexer.MAX_CHAR_VALUE)) {
            cfg = new LexerATNConfig({
              state: trans.target
            }, config);
          }
        }
      }

      return cfg;
    }; // Evaluate a predicate specified in the lexer.
    //
    // <p>If {@code speculative} is {@code true}, this method was called before
    // {@link //consume} for the matched character. This method should call
    // {@link //consume} before evaluating the predicate to ensure position
    // sensitive values, including {@link Lexer//getText}, {@link Lexer//getLine},
    // and {@link Lexer//getcolumn}, properly reflect the current
    // lexer state. This method should restore {@code input} and the simulator
    // to the original state before returning (i.e. undo the actions made by the
    // call to {@link //consume}.</p>
    //
    // @param input The input stream.
    // @param ruleIndex The rule containing the predicate.
    // @param predIndex The index of the predicate within the rule.
    // @param speculative {@code true} if the current index in {@code input} is
    // one character before the predicate's location.
    //
    // @return {@code true} if the specified predicate evaluates to
    // {@code true}.
    // /


    LexerATNSimulator.prototype.evaluatePredicate = function (input, ruleIndex, predIndex, speculative) {
      // assume true if no recognizer was provided
      if (this.recog === null) {
        return true;
      }

      if (!speculative) {
        return this.recog.sempred(null, ruleIndex, predIndex);
      }

      var savedcolumn = this.column;
      var savedLine = this.line;
      var index = input.index;
      var marker = input.mark();

      try {
        this.consume(input);
        return this.recog.sempred(null, ruleIndex, predIndex);
      } finally {
        this.column = savedcolumn;
        this.line = savedLine;
        input.seek(index);
        input.release(marker);
      }
    };

    LexerATNSimulator.prototype.captureSimState = function (settings, input, dfaState) {
      settings.index = input.index;
      settings.line = this.line;
      settings.column = this.column;
      settings.dfaState = dfaState;
    };

    LexerATNSimulator.prototype.addDFAEdge = function (from_, tk, to, cfgs) {
      if (to === undefined) {
        to = null;
      }

      if (cfgs === undefined) {
        cfgs = null;
      }

      if (to === null && cfgs !== null) {
        // leading to this call, ATNConfigSet.hasSemanticContext is used as a
        // marker indicating dynamic predicate evaluation makes this edge
        // dependent on the specific input sequence, so the static edge in the
        // DFA should be omitted. The target DFAState is still created since
        // execATN has the ability to resynchronize with the DFA state cache
        // following the predicate evaluation step.
        //
        // TJP notes: next time through the DFA, we see a pred again and eval.
        // If that gets us to a previously created (but dangling) DFA
        // state, we can continue in pure DFA mode from there.
        // /
        var suppressEdge = cfgs.hasSemanticContext;
        cfgs.hasSemanticContext = false;
        to = this.addDFAState(cfgs);

        if (suppressEdge) {
          return to;
        }
      } // add the edge


      if (tk < LexerATNSimulator.MIN_DFA_EDGE || tk > LexerATNSimulator.MAX_DFA_EDGE) {
        // Only track edges within the DFA bounds
        return to;
      }

      if (LexerATNSimulator.debug) {
        console.log("EDGE " + from_ + " -> " + to + " upon " + tk);
      }

      if (from_.edges === null) {
        // make room for tokens 1..n and -1 masquerading as index 0
        from_.edges = [];
      }

      from_.edges[tk - LexerATNSimulator.MIN_DFA_EDGE] = to; // connect

      return to;
    }; // Add a new DFA state if there isn't one with this set of
    // configurations already. This method also detects the first
    // configuration containing an ATN rule stop state. Later, when
    // traversing the DFA, we will know which rule to accept.


    LexerATNSimulator.prototype.addDFAState = function (configs) {
      var proposed = new DFAState(null, configs);
      var firstConfigWithRuleStopState = null;

      for (var i = 0; i < configs.items.length; i++) {
        var cfg = configs.items[i];

        if (cfg.state instanceof RuleStopState) {
          firstConfigWithRuleStopState = cfg;
          break;
        }
      }

      if (firstConfigWithRuleStopState !== null) {
        proposed.isAcceptState = true;
        proposed.lexerActionExecutor = firstConfigWithRuleStopState.lexerActionExecutor;
        proposed.prediction = this.atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex];
      }

      var dfa = this.decisionToDFA[this.mode];
      var existing = dfa.states.get(proposed);

      if (existing !== null) {
        return existing;
      }

      var newState = proposed;
      newState.stateNumber = dfa.states.length;
      configs.setReadonly(true);
      newState.configs = configs;
      dfa.states.add(newState);
      return newState;
    };

    LexerATNSimulator.prototype.getDFA = function (mode) {
      return this.decisionToDFA[mode];
    }; // Get the text matched so far for the current token.


    LexerATNSimulator.prototype.getText = function (input) {
      // index is first lookahead char, don't include.
      return input.getText(this.startIndex, input.index - 1);
    };

    LexerATNSimulator.prototype.consume = function (input) {
      var curChar = input.LA(1);

      if (curChar === "\n".charCodeAt(0)) {
        this.line += 1;
        this.column = 0;
      } else {
        this.column += 1;
      }

      input.consume();
    };

    LexerATNSimulator.prototype.getTokenName = function (tt) {
      if (tt === -1) {
        return "EOF";
      } else {
        return "'" + String.fromCharCode(tt) + "'";
      }
    };

    exports.LexerATNSimulator = LexerATNSimulator;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/LexerAction.js":
  /*!************************************************!*\
    !*** ./node_modules/antlr4/atn/LexerAction.js ***!
    \************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_LexerActionJs(module, exports) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    function LexerActionType() {}

    LexerActionType.CHANNEL = 0; //The type of a {@link LexerChannelAction} action.

    LexerActionType.CUSTOM = 1; //The type of a {@link LexerCustomAction} action.

    LexerActionType.MODE = 2; //The type of a {@link LexerModeAction} action.

    LexerActionType.MORE = 3; //The type of a {@link LexerMoreAction} action.

    LexerActionType.POP_MODE = 4; //The type of a {@link LexerPopModeAction} action.

    LexerActionType.PUSH_MODE = 5; //The type of a {@link LexerPushModeAction} action.

    LexerActionType.SKIP = 6; //The type of a {@link LexerSkipAction} action.

    LexerActionType.TYPE = 7; //The type of a {@link LexerTypeAction} action.

    function LexerAction(action) {
      this.actionType = action;
      this.isPositionDependent = false;
      return this;
    }

    LexerAction.prototype.hashCode = function () {
      var hash = new Hash();
      this.updateHashCode(hash);
      return hash.finish();
    };

    LexerAction.prototype.updateHashCode = function (hash) {
      hash.update(this.actionType);
    };

    LexerAction.prototype.equals = function (other) {
      return this === other;
    }; //
    // Implements the {@code skip} lexer action by calling {@link Lexer//skip}.
    //
    // <p>The {@code skip} command does not have any parameters, so this action is
    // implemented as a singleton instance exposed by {@link //INSTANCE}.</p>


    function LexerSkipAction() {
      LexerAction.call(this, LexerActionType.SKIP);
      return this;
    }

    LexerSkipAction.prototype = Object.create(LexerAction.prototype);
    LexerSkipAction.prototype.constructor = LexerSkipAction; // Provides a singleton instance of this parameterless lexer action.

    LexerSkipAction.INSTANCE = new LexerSkipAction();

    LexerSkipAction.prototype.execute = function (lexer) {
      lexer.skip();
    };

    LexerSkipAction.prototype.toString = function () {
      return "skip";
    }; //  Implements the {@code type} lexer action by calling {@link Lexer//setType}
    // with the assigned type.


    function LexerTypeAction(type) {
      LexerAction.call(this, LexerActionType.TYPE);
      this.type = type;
      return this;
    }

    LexerTypeAction.prototype = Object.create(LexerAction.prototype);
    LexerTypeAction.prototype.constructor = LexerTypeAction;

    LexerTypeAction.prototype.execute = function (lexer) {
      lexer.type = this.type;
    };

    LexerTypeAction.prototype.updateHashCode = function (hash) {
      hash.update(this.actionType, this.type);
    };

    LexerTypeAction.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof LexerTypeAction)) {
        return false;
      } else {
        return this.type === other.type;
      }
    };

    LexerTypeAction.prototype.toString = function () {
      return "type(" + this.type + ")";
    }; // Implements the {@code pushMode} lexer action by calling
    // {@link Lexer//pushMode} with the assigned mode.


    function LexerPushModeAction(mode) {
      LexerAction.call(this, LexerActionType.PUSH_MODE);
      this.mode = mode;
      return this;
    }

    LexerPushModeAction.prototype = Object.create(LexerAction.prototype);
    LexerPushModeAction.prototype.constructor = LexerPushModeAction; // <p>This action is implemented by calling {@link Lexer//pushMode} with the
    // value provided by {@link //getMode}.</p>

    LexerPushModeAction.prototype.execute = function (lexer) {
      lexer.pushMode(this.mode);
    };

    LexerPushModeAction.prototype.updateHashCode = function (hash) {
      hash.update(this.actionType, this.mode);
    };

    LexerPushModeAction.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof LexerPushModeAction)) {
        return false;
      } else {
        return this.mode === other.mode;
      }
    };

    LexerPushModeAction.prototype.toString = function () {
      return "pushMode(" + this.mode + ")";
    }; // Implements the {@code popMode} lexer action by calling {@link Lexer//popMode}.
    //
    // <p>The {@code popMode} command does not have any parameters, so this action is
    // implemented as a singleton instance exposed by {@link //INSTANCE}.</p>


    function LexerPopModeAction() {
      LexerAction.call(this, LexerActionType.POP_MODE);
      return this;
    }

    LexerPopModeAction.prototype = Object.create(LexerAction.prototype);
    LexerPopModeAction.prototype.constructor = LexerPopModeAction;
    LexerPopModeAction.INSTANCE = new LexerPopModeAction(); // <p>This action is implemented by calling {@link Lexer//popMode}.</p>

    LexerPopModeAction.prototype.execute = function (lexer) {
      lexer.popMode();
    };

    LexerPopModeAction.prototype.toString = function () {
      return "popMode";
    }; // Implements the {@code more} lexer action by calling {@link Lexer//more}.
    //
    // <p>The {@code more} command does not have any parameters, so this action is
    // implemented as a singleton instance exposed by {@link //INSTANCE}.</p>


    function LexerMoreAction() {
      LexerAction.call(this, LexerActionType.MORE);
      return this;
    }

    LexerMoreAction.prototype = Object.create(LexerAction.prototype);
    LexerMoreAction.prototype.constructor = LexerMoreAction;
    LexerMoreAction.INSTANCE = new LexerMoreAction(); // <p>This action is implemented by calling {@link Lexer//popMode}.</p>

    LexerMoreAction.prototype.execute = function (lexer) {
      lexer.more();
    };

    LexerMoreAction.prototype.toString = function () {
      return "more";
    }; // Implements the {@code mode} lexer action by calling {@link Lexer//mode} with
    // the assigned mode.


    function LexerModeAction(mode) {
      LexerAction.call(this, LexerActionType.MODE);
      this.mode = mode;
      return this;
    }

    LexerModeAction.prototype = Object.create(LexerAction.prototype);
    LexerModeAction.prototype.constructor = LexerModeAction; // <p>This action is implemented by calling {@link Lexer//mode} with the
    // value provided by {@link //getMode}.</p>

    LexerModeAction.prototype.execute = function (lexer) {
      lexer.mode(this.mode);
    };

    LexerModeAction.prototype.updateHashCode = function (hash) {
      hash.update(this.actionType, this.mode);
    };

    LexerModeAction.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof LexerModeAction)) {
        return false;
      } else {
        return this.mode === other.mode;
      }
    };

    LexerModeAction.prototype.toString = function () {
      return "mode(" + this.mode + ")";
    }; // Executes a custom lexer action by calling {@link Recognizer//action} with the
    // rule and action indexes assigned to the custom action. The implementation of
    // a custom action is added to the generated code for the lexer in an override
    // of {@link Recognizer//action} when the grammar is compiled.
    //
    // <p>This class may represent embedded actions created with the <code>{...}</code>
    // syntax in ANTLR 4, as well as actions created for lexer commands where the
    // command argument could not be evaluated when the grammar was compiled.</p>
    // Constructs a custom lexer action with the specified rule and action
    // indexes.
    //
    // @param ruleIndex The rule index to use for calls to
    // {@link Recognizer//action}.
    // @param actionIndex The action index to use for calls to
    // {@link Recognizer//action}.


    function LexerCustomAction(ruleIndex, actionIndex) {
      LexerAction.call(this, LexerActionType.CUSTOM);
      this.ruleIndex = ruleIndex;
      this.actionIndex = actionIndex;
      this.isPositionDependent = true;
      return this;
    }

    LexerCustomAction.prototype = Object.create(LexerAction.prototype);
    LexerCustomAction.prototype.constructor = LexerCustomAction; // <p>Custom actions are implemented by calling {@link Lexer//action} with the
    // appropriate rule and action indexes.</p>

    LexerCustomAction.prototype.execute = function (lexer) {
      lexer.action(null, this.ruleIndex, this.actionIndex);
    };

    LexerCustomAction.prototype.updateHashCode = function (hash) {
      hash.update(this.actionType, this.ruleIndex, this.actionIndex);
    };

    LexerCustomAction.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof LexerCustomAction)) {
        return false;
      } else {
        return this.ruleIndex === other.ruleIndex && this.actionIndex === other.actionIndex;
      }
    }; // Implements the {@code channel} lexer action by calling
    // {@link Lexer//setChannel} with the assigned channel.
    // Constructs a new {@code channel} action with the specified channel value.
    // @param channel The channel value to pass to {@link Lexer//setChannel}.


    function LexerChannelAction(channel) {
      LexerAction.call(this, LexerActionType.CHANNEL);
      this.channel = channel;
      return this;
    }

    LexerChannelAction.prototype = Object.create(LexerAction.prototype);
    LexerChannelAction.prototype.constructor = LexerChannelAction; // <p>This action is implemented by calling {@link Lexer//setChannel} with the
    // value provided by {@link //getChannel}.</p>

    LexerChannelAction.prototype.execute = function (lexer) {
      lexer._channel = this.channel;
    };

    LexerChannelAction.prototype.updateHashCode = function (hash) {
      hash.update(this.actionType, this.channel);
    };

    LexerChannelAction.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof LexerChannelAction)) {
        return false;
      } else {
        return this.channel === other.channel;
      }
    };

    LexerChannelAction.prototype.toString = function () {
      return "channel(" + this.channel + ")";
    }; // This implementation of {@link LexerAction} is used for tracking input offsets
    // for position-dependent actions within a {@link LexerActionExecutor}.
    //
    // <p>This action is not serialized as part of the ATN, and is only required for
    // position-dependent lexer actions which appear at a location other than the
    // end of a rule. For more information about DFA optimizations employed for
    // lexer actions, see {@link LexerActionExecutor//append} and
    // {@link LexerActionExecutor//fixOffsetBeforeMatch}.</p>
    // Constructs a new indexed custom action by associating a character offset
    // with a {@link LexerAction}.
    //
    // <p>Note: This class is only required for lexer actions for which
    // {@link LexerAction//isPositionDependent} returns {@code true}.</p>
    //
    // @param offset The offset into the input {@link CharStream}, relative to
    // the token start index, at which the specified lexer action should be
    // executed.
    // @param action The lexer action to execute at a particular offset in the
    // input {@link CharStream}.


    function LexerIndexedCustomAction(offset, action) {
      LexerAction.call(this, action.actionType);
      this.offset = offset;
      this.action = action;
      this.isPositionDependent = true;
      return this;
    }

    LexerIndexedCustomAction.prototype = Object.create(LexerAction.prototype);
    LexerIndexedCustomAction.prototype.constructor = LexerIndexedCustomAction; // <p>This method calls {@link //execute} on the result of {@link //getAction}
    // using the provided {@code lexer}.</p>

    LexerIndexedCustomAction.prototype.execute = function (lexer) {
      // assume the input stream position was properly set by the calling code
      this.action.execute(lexer);
    };

    LexerIndexedCustomAction.prototype.updateHashCode = function (hash) {
      hash.update(this.actionType, this.offset, this.action);
    };

    LexerIndexedCustomAction.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof LexerIndexedCustomAction)) {
        return false;
      } else {
        return this.offset === other.offset && this.action === other.action;
      }
    };

    exports.LexerActionType = LexerActionType;
    exports.LexerSkipAction = LexerSkipAction;
    exports.LexerChannelAction = LexerChannelAction;
    exports.LexerCustomAction = LexerCustomAction;
    exports.LexerIndexedCustomAction = LexerIndexedCustomAction;
    exports.LexerMoreAction = LexerMoreAction;
    exports.LexerTypeAction = LexerTypeAction;
    exports.LexerPushModeAction = LexerPushModeAction;
    exports.LexerPopModeAction = LexerPopModeAction;
    exports.LexerModeAction = LexerModeAction;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/LexerActionExecutor.js":
  /*!********************************************************!*\
    !*** ./node_modules/antlr4/atn/LexerActionExecutor.js ***!
    \********************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_LexerActionExecutorJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    // Represents an executor for a sequence of lexer actions which traversed during
    // the matching operation of a lexer rule (token).
    //
    // <p>The executor tracks position information for position-dependent lexer actions
    // efficiently, ensuring that actions appearing only at the end of the rule do
    // not cause bloating of the {@link DFA} created for the lexer.</p>
    var hashStuff = __webpack_require__(
    /*! ../Utils */
    "./node_modules/antlr4/Utils.js").hashStuff;

    var LexerIndexedCustomAction = __webpack_require__(
    /*! ./LexerAction */
    "./node_modules/antlr4/atn/LexerAction.js").LexerIndexedCustomAction;

    function LexerActionExecutor(lexerActions) {
      this.lexerActions = lexerActions === null ? [] : lexerActions; // Caches the result of {@link //hashCode} since the hash code is an element
      // of the performance-critical {@link LexerATNConfig//hashCode} operation.

      this.cachedHashCode = hashStuff(lexerActions); // "".join([str(la) for la in
      // lexerActions]))

      return this;
    } // Creates a {@link LexerActionExecutor} which executes the actions for
    // the input {@code lexerActionExecutor} followed by a specified
    // {@code lexerAction}.
    //
    // @param lexerActionExecutor The executor for actions already traversed by
    // the lexer while matching a token within a particular
    // {@link LexerATNConfig}. If this is {@code null}, the method behaves as
    // though it were an empty executor.
    // @param lexerAction The lexer action to execute after the actions
    // specified in {@code lexerActionExecutor}.
    //
    // @return A {@link LexerActionExecutor} for executing the combine actions
    // of {@code lexerActionExecutor} and {@code lexerAction}.


    LexerActionExecutor.append = function (lexerActionExecutor, lexerAction) {
      if (lexerActionExecutor === null) {
        return new LexerActionExecutor([lexerAction]);
      }

      var lexerActions = lexerActionExecutor.lexerActions.concat([lexerAction]);
      return new LexerActionExecutor(lexerActions);
    }; // Creates a {@link LexerActionExecutor} which encodes the current offset
    // for position-dependent lexer actions.
    //
    // <p>Normally, when the executor encounters lexer actions where
    // {@link LexerAction//isPositionDependent} returns {@code true}, it calls
    // {@link IntStream//seek} on the input {@link CharStream} to set the input
    // position to the <em>end</em> of the current token. This behavior provides
    // for efficient DFA representation of lexer actions which appear at the end
    // of a lexer rule, even when the lexer rule matches a variable number of
    // characters.</p>
    //
    // <p>Prior to traversing a match transition in the ATN, the current offset
    // from the token start index is assigned to all position-dependent lexer
    // actions which have not already been assigned a fixed offset. By storing
    // the offsets relative to the token start index, the DFA representation of
    // lexer actions which appear in the middle of tokens remains efficient due
    // to sharing among tokens of the same length, regardless of their absolute
    // position in the input stream.</p>
    //
    // <p>If the current executor already has offsets assigned to all
    // position-dependent lexer actions, the method returns {@code this}.</p>
    //
    // @param offset The current offset to assign to all position-dependent
    // lexer actions which do not already have offsets assigned.
    //
    // @return A {@link LexerActionExecutor} which stores input stream offsets
    // for all position-dependent lexer actions.
    // /


    LexerActionExecutor.prototype.fixOffsetBeforeMatch = function (offset) {
      var updatedLexerActions = null;

      for (var i = 0; i < this.lexerActions.length; i++) {
        if (this.lexerActions[i].isPositionDependent && !(this.lexerActions[i] instanceof LexerIndexedCustomAction)) {
          if (updatedLexerActions === null) {
            updatedLexerActions = this.lexerActions.concat([]);
          }

          updatedLexerActions[i] = new LexerIndexedCustomAction(offset, this.lexerActions[i]);
        }
      }

      if (updatedLexerActions === null) {
        return this;
      } else {
        return new LexerActionExecutor(updatedLexerActions);
      }
    }; // Execute the actions encapsulated by this executor within the context of a
    // particular {@link Lexer}.
    //
    // <p>This method calls {@link IntStream//seek} to set the position of the
    // {@code input} {@link CharStream} prior to calling
    // {@link LexerAction//execute} on a position-dependent action. Before the
    // method returns, the input position will be restored to the same position
    // it was in when the method was invoked.</p>
    //
    // @param lexer The lexer instance.
    // @param input The input stream which is the source for the current token.
    // When this method is called, the current {@link IntStream//index} for
    // {@code input} should be the start of the following token, i.e. 1
    // character past the end of the current token.
    // @param startIndex The token start index. This value may be passed to
    // {@link IntStream//seek} to set the {@code input} position to the beginning
    // of the token.
    // /


    LexerActionExecutor.prototype.execute = function (lexer, input, startIndex) {
      var requiresSeek = false;
      var stopIndex = input.index;

      try {
        for (var i = 0; i < this.lexerActions.length; i++) {
          var lexerAction = this.lexerActions[i];

          if (lexerAction instanceof LexerIndexedCustomAction) {
            var offset = lexerAction.offset;
            input.seek(startIndex + offset);
            lexerAction = lexerAction.action;
            requiresSeek = startIndex + offset !== stopIndex;
          } else if (lexerAction.isPositionDependent) {
            input.seek(stopIndex);
            requiresSeek = false;
          }

          lexerAction.execute(lexer);
        }
      } finally {
        if (requiresSeek) {
          input.seek(stopIndex);
        }
      }
    };

    LexerActionExecutor.prototype.hashCode = function () {
      return this.cachedHashCode;
    };

    LexerActionExecutor.prototype.updateHashCode = function (hash) {
      hash.update(this.cachedHashCode);
    };

    LexerActionExecutor.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof LexerActionExecutor)) {
        return false;
      } else if (this.cachedHashCode != other.cachedHashCode) {
        return false;
      } else if (this.lexerActions.length != other.lexerActions.length) {
        return false;
      } else {
        var numActions = this.lexerActions.length;

        for (var idx = 0; idx < numActions; ++idx) {
          if (!this.lexerActions[idx].equals(other.lexerActions[idx])) {
            return false;
          }
        }

        return true;
      }
    };

    exports.LexerActionExecutor = LexerActionExecutor;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/ParserATNSimulator.js":
  /*!*******************************************************!*\
    !*** ./node_modules/antlr4/atn/ParserATNSimulator.js ***!
    \*******************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_ParserATNSimulatorJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    //
    // The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
    //
    // <p>
    // The basic complexity of the adaptive strategy makes it harder to understand.
    // We begin with ATN simulation to build paths in a DFA. Subsequent prediction
    // requests go through the DFA first. If they reach a state without an edge for
    // the current symbol, the algorithm fails over to the ATN simulation to
    // complete the DFA path for the current input (until it finds a conflict state
    // or uniquely predicting state).</p>
    //
    // <p>
    // All of that is done without using the outer context because we want to create
    // a DFA that is not dependent upon the rule invocation stack when we do a
    // prediction. One DFA works in all contexts. We avoid using context not
    // necessarily because it's slower, although it can be, but because of the DFA
    // caching problem. The closure routine only considers the rule invocation stack
    // created during prediction beginning in the decision rule. For example, if
    // prediction occurs without invoking another rule's ATN, there are no context
    // stacks in the configurations. When lack of context leads to a conflict, we
    // don't know if it's an ambiguity or a weakness in the strong LL(*) parsing
    // strategy (versus full LL(*)).</p>
    //
    // <p>
    // When SLL yields a configuration set with conflict, we rewind the input and
    // retry the ATN simulation, this time using full outer context without adding
    // to the DFA. Configuration context stacks will be the full invocation stacks
    // from the start rule. If we get a conflict using full context, then we can
    // definitively say we have a true ambiguity for that input sequence. If we
    // don't get a conflict, it implies that the decision is sensitive to the outer
    // context. (It is not context-sensitive in the sense of context-sensitive
    // grammars.)</p>
    //
    // <p>
    // The next time we reach this DFA state with an SLL conflict, through DFA
    // simulation, we will again retry the ATN simulation using full context mode.
    // This is slow because we can't save the results and have to "interpret" the
    // ATN each time we get that input.</p>
    //
    // <p>
    // <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>
    //
    // <p>
    // We could cache results from full context to predicted alternative easily and
    // that saves a lot of time but doesn't work in presence of predicates. The set
    // of visible predicates from the ATN start state changes depending on the
    // context, because closure can fall off the end of a rule. I tried to cache
    // tuples (stack context, semantic context, predicted alt) but it was slower
    // than interpreting and much more complicated. Also required a huge amount of
    // memory. The goal is not to create the world's fastest parser anyway. I'd like
    // to keep this algorithm simple. By launching multiple threads, we can improve
    // the speed of parsing across a large number of files.</p>
    //
    // <p>
    // There is no strict ordering between the amount of input used by SLL vs LL,
    // which makes it really hard to build a cache for full context. Let's say that
    // we have input A B C that leads to an SLL conflict with full context X. That
    // implies that using X we might only use A B but we could also use A B C D to
    // resolve conflict. Input A B C D could predict alternative 1 in one position
    // in the input and A B C E could predict alternative 2 in another position in
    // input. The conflicting SLL configurations could still be non-unique in the
    // full context prediction, which would lead us to requiring more input than the
    // original A B C.	To make a	prediction cache work, we have to track	the exact
    // input	used during the previous prediction. That amounts to a cache that maps
    // X to a specific DFA for that context.</p>
    //
    // <p>
    // Something should be done for left-recursive expression predictions. They are
    // likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry
    // with full LL thing Sam does.</p>
    //
    // <p>
    // <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>
    //
    // <p>
    // We avoid doing full context retry when the outer context is empty, we did not
    // dip into the outer context by falling off the end of the decision state rule,
    // or when we force SLL mode.</p>
    //
    // <p>
    // As an example of the not dip into outer context case, consider as super
    // constructor calls versus function calls. One grammar might look like
    // this:</p>
    //
    // <pre>
    // ctorBody
    //   : '{' superCall? stat* '}'
    //   ;
    // </pre>
    //
    // <p>
    // Or, you might see something like</p>
    //
    // <pre>
    // stat
    //   : superCall ';'
    //   | expression ';'
    //   | ...
    //   ;
    // </pre>
    //
    // <p>
    // In both cases I believe that no closure operations will dip into the outer
    // context. In the first case ctorBody in the worst case will stop at the '}'.
    // In the 2nd case it should stop at the ';'. Both cases should stay within the
    // entry rule and not dip into the outer context.</p>
    //
    // <p>
    // <strong>PREDICATES</strong></p>
    //
    // <p>
    // Predicates are always evaluated if present in either SLL or LL both. SLL and
    // LL simulation deals with predicates differently. SLL collects predicates as
    // it performs closure operations like ANTLR v3 did. It delays predicate
    // evaluation until it reaches and accept state. This allows us to cache the SLL
    // ATN simulation whereas, if we had evaluated predicates on-the-fly during
    // closure, the DFA state configuration sets would be different and we couldn't
    // build up a suitable DFA.</p>
    //
    // <p>
    // When building a DFA accept state during ATN simulation, we evaluate any
    // predicates and return the sole semantically valid alternative. If there is
    // more than 1 alternative, we report an ambiguity. If there are 0 alternatives,
    // we throw an exception. Alternatives without predicates act like they have
    // true predicates. The simple way to think about it is to strip away all
    // alternatives with false predicates and choose the minimum alternative that
    // remains.</p>
    //
    // <p>
    // When we start in the DFA and reach an accept state that's predicated, we test
    // those and return the minimum semantically viable alternative. If no
    // alternatives are viable, we throw an exception.</p>
    //
    // <p>
    // During full LL ATN simulation, closure always evaluates predicates and
    // on-the-fly. This is crucial to reducing the configuration set size during
    // closure. It hits a landmine when parsing with the Java grammar, for example,
    // without this on-the-fly evaluation.</p>
    //
    // <p>
    // <strong>SHARING DFA</strong></p>
    //
    // <p>
    // All instances of the same parser share the same decision DFAs through a
    // static field. Each instance gets its own ATN simulator but they share the
    // same {@link //decisionToDFA} field. They also share a
    // {@link PredictionContextCache} object that makes sure that all
    // {@link PredictionContext} objects are shared among the DFA states. This makes
    // a big size difference.</p>
    //
    // <p>
    // <strong>THREAD SAFETY</strong></p>
    //
    // <p>
    // The {@link ParserATNSimulator} locks on the {@link //decisionToDFA} field when
    // it adds a new DFA object to that array. {@link //addDFAEdge}
    // locks on the DFA for the current decision when setting the
    // {@link DFAState//edges} field. {@link //addDFAState} locks on
    // the DFA for the current decision when looking up a DFA state to see if it
    // already exists. We must make sure that all requests to add DFA states that
    // are equivalent result in the same shared DFA object. This is because lots of
    // threads will be trying to update the DFA at once. The
    // {@link //addDFAState} method also locks inside the DFA lock
    // but this time on the shared context cache when it rebuilds the
    // configurations' {@link PredictionContext} objects using cached
    // subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
    // safe as long as we can guarantee that all threads referencing
    // {@code s.edge[t]} get the same physical target {@link DFAState}, or
    // {@code null}. Once into the DFA, the DFA simulation does not reference the
    // {@link DFA//states} map. It follows the {@link DFAState//edges} field to new
    // targets. The DFA simulator will either find {@link DFAState//edges} to be
    // {@code null}, to be non-{@code null} and {@code dfa.edges[t]} null, or
    // {@code dfa.edges[t]} to be non-null. The
    // {@link //addDFAEdge} method could be racing to set the field
    // but in either case the DFA simulator works; if {@code null}, and requests ATN
    // simulation. It could also race trying to get {@code dfa.edges[t]}, but either
    // way it will work because it's not doing a test and set operation.</p>
    //
    // <p>
    // <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage
    // Parsing)</strong></p>
    //
    // <p>
    // Sam pointed out that if SLL does not give a syntax error, then there is no
    // point in doing full LL, which is slower. We only have to try LL if we get a
    // syntax error. For maximum speed, Sam starts the parser set to pure SLL
    // mode with the {@link BailErrorStrategy}:</p>
    //
    // <pre>
    // parser.{@link Parser//getInterpreter() getInterpreter()}.{@link //setPredictionMode setPredictionMode}{@code (}{@link PredictionMode//SLL}{@code )};
    // parser.{@link Parser//setErrorHandler setErrorHandler}(new {@link BailErrorStrategy}());
    // </pre>
    //
    // <p>
    // If it does not get a syntax error, then we're done. If it does get a syntax
    // error, we need to retry with the combined SLL/LL strategy.</p>
    //
    // <p>
    // The reason this works is as follows. If there are no SLL conflicts, then the
    // grammar is SLL (at least for that input set). If there is an SLL conflict,
    // the full LL analysis must yield a set of viable alternatives which is a
    // subset of the alternatives reported by SLL. If the LL set is a singleton,
    // then the grammar is LL but not SLL. If the LL set is the same size as the SLL
    // set, the decision is SLL. If the LL set has size &gt; 1, then that decision
    // is truly ambiguous on the current input. If the LL set is smaller, then the
    // SLL conflict resolution might choose an alternative that the full LL would
    // rule out as a possibility based upon better context information. If that's
    // the case, then the SLL parse will definitely get an error because the full LL
    // analysis says it's not viable. If SLL conflict resolution chooses an
    // alternative within the LL set, them both SLL and LL would choose the same
    // alternative because they both choose the minimum of multiple conflicting
    // alternatives.</p>
    //
    // <p>
    // Let's say we have a set of SLL conflicting alternatives {@code {1, 2, 3}} and
    // a smaller LL set called <em>s</em>. If <em>s</em> is {@code {2, 3}}, then SLL
    // parsing will get an error because SLL will pursue alternative 1. If
    // <em>s</em> is {@code {1, 2}} or {@code {1, 3}} then both SLL and LL will
    // choose the same alternative because alternative one is the minimum of either
    // set. If <em>s</em> is {@code {2}} or {@code {3}} then SLL will get a syntax
    // error. If <em>s</em> is {@code {1}} then SLL will succeed.</p>
    //
    // <p>
    // Of course, if the input is invalid, then we will get an error for sure in
    // both SLL and LL parsing. Erroneous input will therefore require 2 passes over
    // the input.</p>
    //
    var Utils = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js");

    var Set = Utils.Set;
    var BitSet = Utils.BitSet;
    var DoubleDict = Utils.DoubleDict;

    var ATN = __webpack_require__(
    /*! ./ATN */
    "./node_modules/antlr4/atn/ATN.js").ATN;

    var ATNState = __webpack_require__(
    /*! ./ATNState */
    "./node_modules/antlr4/atn/ATNState.js").ATNState;

    var ATNConfig = __webpack_require__(
    /*! ./ATNConfig */
    "./node_modules/antlr4/atn/ATNConfig.js").ATNConfig;

    var ATNConfigSet = __webpack_require__(
    /*! ./ATNConfigSet */
    "./node_modules/antlr4/atn/ATNConfigSet.js").ATNConfigSet;

    var Token = __webpack_require__(
    /*! ./../Token */
    "./node_modules/antlr4/Token.js").Token;

    var DFAState = __webpack_require__(
    /*! ./../dfa/DFAState */
    "./node_modules/antlr4/dfa/DFAState.js").DFAState;

    var PredPrediction = __webpack_require__(
    /*! ./../dfa/DFAState */
    "./node_modules/antlr4/dfa/DFAState.js").PredPrediction;

    var ATNSimulator = __webpack_require__(
    /*! ./ATNSimulator */
    "./node_modules/antlr4/atn/ATNSimulator.js").ATNSimulator;

    var PredictionMode = __webpack_require__(
    /*! ./PredictionMode */
    "./node_modules/antlr4/atn/PredictionMode.js").PredictionMode;

    var RuleContext = __webpack_require__(
    /*! ./../RuleContext */
    "./node_modules/antlr4/RuleContext.js").RuleContext;

    var ParserRuleContext = __webpack_require__(
    /*! ./../ParserRuleContext */
    "./node_modules/antlr4/ParserRuleContext.js").ParserRuleContext;

    var SemanticContext = __webpack_require__(
    /*! ./SemanticContext */
    "./node_modules/antlr4/atn/SemanticContext.js").SemanticContext;

    var StarLoopEntryState = __webpack_require__(
    /*! ./ATNState */
    "./node_modules/antlr4/atn/ATNState.js").StarLoopEntryState;

    var RuleStopState = __webpack_require__(
    /*! ./ATNState */
    "./node_modules/antlr4/atn/ATNState.js").RuleStopState;

    var PredictionContext = __webpack_require__(
    /*! ./../PredictionContext */
    "./node_modules/antlr4/PredictionContext.js").PredictionContext;

    var Interval = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval;

    var Transitions = __webpack_require__(
    /*! ./Transition */
    "./node_modules/antlr4/atn/Transition.js");

    var Transition = Transitions.Transition;
    var SetTransition = Transitions.SetTransition;
    var NotSetTransition = Transitions.NotSetTransition;
    var RuleTransition = Transitions.RuleTransition;
    var ActionTransition = Transitions.ActionTransition;

    var NoViableAltException = __webpack_require__(
    /*! ./../error/Errors */
    "./node_modules/antlr4/error/Errors.js").NoViableAltException;

    var SingletonPredictionContext = __webpack_require__(
    /*! ./../PredictionContext */
    "./node_modules/antlr4/PredictionContext.js").SingletonPredictionContext;

    var predictionContextFromRuleContext = __webpack_require__(
    /*! ./../PredictionContext */
    "./node_modules/antlr4/PredictionContext.js").predictionContextFromRuleContext;

    function ParserATNSimulator(parser, atn, decisionToDFA, sharedContextCache) {
      ATNSimulator.call(this, atn, sharedContextCache);
      this.parser = parser;
      this.decisionToDFA = decisionToDFA; // SLL, LL, or LL + exact ambig detection?//

      this.predictionMode = PredictionMode.LL; // LAME globals to avoid parameters!!!!! I need these down deep in predTransition

      this._input = null;
      this._startIndex = 0;
      this._outerContext = null;
      this._dfa = null; // Each prediction operation uses a cache for merge of prediction contexts.
      //  Don't keep around as it wastes huge amounts of memory. DoubleKeyMap
      //  isn't synchronized but we're ok since two threads shouldn't reuse same
      //  parser/atnsim object because it can only handle one input at a time.
      //  This maps graphs a and b to merged result c. (a,b)&rarr;c. We can avoid
      //  the merge if we ever see a and b again.  Note that (b,a)&rarr;c should
      //  also be examined during cache lookup.
      //

      this.mergeCache = null;
      return this;
    }

    ParserATNSimulator.prototype = Object.create(ATNSimulator.prototype);
    ParserATNSimulator.prototype.constructor = ParserATNSimulator;
    ParserATNSimulator.prototype.debug = false;
    ParserATNSimulator.prototype.debug_closure = false;
    ParserATNSimulator.prototype.debug_add = false;
    ParserATNSimulator.prototype.debug_list_atn_decisions = false;
    ParserATNSimulator.prototype.dfa_debug = false;
    ParserATNSimulator.prototype.retry_debug = false;

    ParserATNSimulator.prototype.reset = function () {};

    ParserATNSimulator.prototype.adaptivePredict = function (input, decision, outerContext) {
      if (this.debug || this.debug_list_atn_decisions) {
        console.log("adaptivePredict decision " + decision + " exec LA(1)==" + this.getLookaheadName(input) + " line " + input.LT(1).line + ":" + input.LT(1).column);
      }

      this._input = input;
      this._startIndex = input.index;
      this._outerContext = outerContext;
      var dfa = this.decisionToDFA[decision];
      this._dfa = dfa;
      var m = input.mark();
      var index = input.index; // Now we are certain to have a specific decision's DFA
      // But, do we still need an initial state?

      try {
        var s0;

        if (dfa.precedenceDfa) {
          // the start state for a precedence DFA depends on the current
          // parser precedence, and is provided by a DFA method.
          s0 = dfa.getPrecedenceStartState(this.parser.getPrecedence());
        } else {
          // the start state for a "regular" DFA is just s0
          s0 = dfa.s0;
        }

        if (s0 === null) {
          if (outerContext === null) {
            outerContext = RuleContext.EMPTY;
          }

          if (this.debug || this.debug_list_atn_decisions) {
            console.log("predictATN decision " + dfa.decision + " exec LA(1)==" + this.getLookaheadName(input) + ", outerContext=" + outerContext.toString(this.parser.ruleNames));
          }

          var fullCtx = false;
          var s0_closure = this.computeStartState(dfa.atnStartState, RuleContext.EMPTY, fullCtx);

          if (dfa.precedenceDfa) {
            // If this is a precedence DFA, we use applyPrecedenceFilter
            // to convert the computed start state to a precedence start
            // state. We then use DFA.setPrecedenceStartState to set the
            // appropriate start state for the precedence level rather
            // than simply setting DFA.s0.
            //
            dfa.s0.configs = s0_closure; // not used for prediction but useful to know start configs anyway

            s0_closure = this.applyPrecedenceFilter(s0_closure);
            s0 = this.addDFAState(dfa, new DFAState(null, s0_closure));
            dfa.setPrecedenceStartState(this.parser.getPrecedence(), s0);
          } else {
            s0 = this.addDFAState(dfa, new DFAState(null, s0_closure));
            dfa.s0 = s0;
          }
        }

        var alt = this.execATN(dfa, s0, input, index, outerContext);

        if (this.debug) {
          console.log("DFA after predictATN: " + dfa.toString(this.parser.literalNames));
        }

        return alt;
      } finally {
        this._dfa = null;
        this.mergeCache = null; // wack cache after each prediction

        input.seek(index);
        input.release(m);
      }
    }; // Performs ATN simulation to compute a predicted alternative based
    //  upon the remaining input, but also updates the DFA cache to avoid
    //  having to traverse the ATN again for the same input sequence.
    // There are some key conditions we're looking for after computing a new
    // set of ATN configs (proposed DFA state):
    // if the set is empty, there is no viable alternative for current symbol
    // does the state uniquely predict an alternative?
    // does the state have a conflict that would prevent us from
    //   putting it on the work list?
    // We also have some key operations to do:
    // add an edge from previous DFA state to potentially new DFA state, D,
    //   upon current symbol but only if adding to work list, which means in all
    //   cases except no viable alternative (and possibly non-greedy decisions?)
    // collecting predicates and adding semantic context to DFA accept states
    // adding rule context to context-sensitive DFA accept states
    // consuming an input symbol
    // reporting a conflict
    // reporting an ambiguity
    // reporting a context sensitivity
    // reporting insufficient predicates
    // cover these cases:
    //    dead end
    //    single alt
    //    single alt + preds
    //    conflict
    //    conflict + preds
    //


    ParserATNSimulator.prototype.execATN = function (dfa, s0, input, startIndex, outerContext) {
      if (this.debug || this.debug_list_atn_decisions) {
        console.log("execATN decision " + dfa.decision + " exec LA(1)==" + this.getLookaheadName(input) + " line " + input.LT(1).line + ":" + input.LT(1).column);
      }

      var alt;
      var previousD = s0;

      if (this.debug) {
        console.log("s0 = " + s0);
      }

      var t = input.LA(1);

      while (true) {
        // while more work
        var D = this.getExistingTargetState(previousD, t);

        if (D === null) {
          D = this.computeTargetState(dfa, previousD, t);
        }

        if (D === ATNSimulator.ERROR) {
          // if any configs in previous dipped into outer context, that
          // means that input up to t actually finished entry rule
          // at least for SLL decision. Full LL doesn't dip into outer
          // so don't need special case.
          // We will get an error no matter what so delay until after
          // decision; better error message. Also, no reachable target
          // ATN states in SLL implies LL will also get nowhere.
          // If conflict in states that dip out, choose min since we
          // will get error no matter what.
          var e = this.noViableAlt(input, outerContext, previousD.configs, startIndex);
          input.seek(startIndex);
          alt = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD.configs, outerContext);

          if (alt !== ATN.INVALID_ALT_NUMBER) {
            return alt;
          } else {
            throw e;
          }
        }

        if (D.requiresFullContext && this.predictionMode !== PredictionMode.SLL) {
          // IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error)
          var conflictingAlts = null;

          if (D.predicates !== null) {
            if (this.debug) {
              console.log("DFA state has preds in DFA sim LL failover");
            }

            var conflictIndex = input.index;

            if (conflictIndex !== startIndex) {
              input.seek(startIndex);
            }

            conflictingAlts = this.evalSemanticContext(D.predicates, outerContext, true);

            if (conflictingAlts.length === 1) {
              if (this.debug) {
                console.log("Full LL avoided");
              }

              return conflictingAlts.minValue();
            }

            if (conflictIndex !== startIndex) {
              // restore the index so reporting the fallback to full
              // context occurs with the index at the correct spot
              input.seek(conflictIndex);
            }
          }

          if (this.dfa_debug) {
            console.log("ctx sensitive state " + outerContext + " in " + D);
          }

          var fullCtx = true;
          var s0_closure = this.computeStartState(dfa.atnStartState, outerContext, fullCtx);
          this.reportAttemptingFullContext(dfa, conflictingAlts, D.configs, startIndex, input.index);
          alt = this.execATNWithFullContext(dfa, D, s0_closure, input, startIndex, outerContext);
          return alt;
        }

        if (D.isAcceptState) {
          if (D.predicates === null) {
            return D.prediction;
          }

          var stopIndex = input.index;
          input.seek(startIndex);
          var alts = this.evalSemanticContext(D.predicates, outerContext, true);

          if (alts.length === 0) {
            throw this.noViableAlt(input, outerContext, D.configs, startIndex);
          } else if (alts.length === 1) {
            return alts.minValue();
          } else {
            // report ambiguity after predicate evaluation to make sure the correct set of ambig alts is reported.
            this.reportAmbiguity(dfa, D, startIndex, stopIndex, false, alts, D.configs);
            return alts.minValue();
          }
        }

        previousD = D;

        if (t !== Token.EOF) {
          input.consume();
          t = input.LA(1);
        }
      }
    }; //
    // Get an existing target state for an edge in the DFA. If the target state
    // for the edge has not yet been computed or is otherwise not available,
    // this method returns {@code null}.
    //
    // @param previousD The current DFA state
    // @param t The next input symbol
    // @return The existing target DFA state for the given input symbol
    // {@code t}, or {@code null} if the target state for this edge is not
    // already cached
    //


    ParserATNSimulator.prototype.getExistingTargetState = function (previousD, t) {
      var edges = previousD.edges;

      if (edges === null) {
        return null;
      } else {
        return edges[t + 1] || null;
      }
    }; //
    // Compute a target state for an edge in the DFA, and attempt to add the
    // computed state and corresponding edge to the DFA.
    //
    // @param dfa The DFA
    // @param previousD The current DFA state
    // @param t The next input symbol
    //
    // @return The computed target DFA state for the given input symbol
    // {@code t}. If {@code t} does not lead to a valid DFA state, this method
    // returns {@link //ERROR}.
    //


    ParserATNSimulator.prototype.computeTargetState = function (dfa, previousD, t) {
      var reach = this.computeReachSet(previousD.configs, t, false);

      if (reach === null) {
        this.addDFAEdge(dfa, previousD, t, ATNSimulator.ERROR);
        return ATNSimulator.ERROR;
      } // create new target state; we'll add to DFA after it's complete


      var D = new DFAState(null, reach);
      var predictedAlt = this.getUniqueAlt(reach);

      if (this.debug) {
        var altSubSets = PredictionMode.getConflictingAltSubsets(reach);
        console.log("SLL altSubSets=" + Utils.arrayToString(altSubSets) + ", previous=" + previousD.configs + ", configs=" + reach + ", predict=" + predictedAlt + ", allSubsetsConflict=" + PredictionMode.allSubsetsConflict(altSubSets) + ", conflictingAlts=" + this.getConflictingAlts(reach));
      }

      if (predictedAlt !== ATN.INVALID_ALT_NUMBER) {
        // NO CONFLICT, UNIQUELY PREDICTED ALT
        D.isAcceptState = true;
        D.configs.uniqueAlt = predictedAlt;
        D.prediction = predictedAlt;
      } else if (PredictionMode.hasSLLConflictTerminatingPrediction(this.predictionMode, reach)) {
        // MORE THAN ONE VIABLE ALTERNATIVE
        D.configs.conflictingAlts = this.getConflictingAlts(reach);
        D.requiresFullContext = true; // in SLL-only mode, we will stop at this state and return the minimum alt

        D.isAcceptState = true;
        D.prediction = D.configs.conflictingAlts.minValue();
      }

      if (D.isAcceptState && D.configs.hasSemanticContext) {
        this.predicateDFAState(D, this.atn.getDecisionState(dfa.decision));

        if (D.predicates !== null) {
          D.prediction = ATN.INVALID_ALT_NUMBER;
        }
      } // all adds to dfa are done after we've created full D state


      D = this.addDFAEdge(dfa, previousD, t, D);
      return D;
    };

    ParserATNSimulator.prototype.predicateDFAState = function (dfaState, decisionState) {
      // We need to test all predicates, even in DFA states that
      // uniquely predict alternative.
      var nalts = decisionState.transitions.length; // Update DFA so reach becomes accept state with (predicate,alt)
      // pairs if preds found for conflicting alts

      var altsToCollectPredsFrom = this.getConflictingAltsOrUniqueAlt(dfaState.configs);
      var altToPred = this.getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState.configs, nalts);

      if (altToPred !== null) {
        dfaState.predicates = this.getPredicatePredictions(altsToCollectPredsFrom, altToPred);
        dfaState.prediction = ATN.INVALID_ALT_NUMBER; // make sure we use preds
      } else {
        // There are preds in configs but they might go away
        // when OR'd together like {p}? || NONE == NONE. If neither
        // alt has preds, resolve to min alt
        dfaState.prediction = altsToCollectPredsFrom.minValue();
      }
    }; // comes back with reach.uniqueAlt set to a valid alt


    ParserATNSimulator.prototype.execATNWithFullContext = function (dfa, D, // how far we got before failing over
    s0, input, startIndex, outerContext) {
      if (this.debug || this.debug_list_atn_decisions) {
        console.log("execATNWithFullContext " + s0);
      }

      var fullCtx = true;
      var foundExactAmbig = false;
      var reach = null;
      var previous = s0;
      input.seek(startIndex);
      var t = input.LA(1);
      var predictedAlt = -1;

      while (true) {
        // while more work
        reach = this.computeReachSet(previous, t, fullCtx);

        if (reach === null) {
          // if any configs in previous dipped into outer context, that
          // means that input up to t actually finished entry rule
          // at least for LL decision. Full LL doesn't dip into outer
          // so don't need special case.
          // We will get an error no matter what so delay until after
          // decision; better error message. Also, no reachable target
          // ATN states in SLL implies LL will also get nowhere.
          // If conflict in states that dip out, choose min since we
          // will get error no matter what.
          var e = this.noViableAlt(input, outerContext, previous, startIndex);
          input.seek(startIndex);
          var alt = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext);

          if (alt !== ATN.INVALID_ALT_NUMBER) {
            return alt;
          } else {
            throw e;
          }
        }

        var altSubSets = PredictionMode.getConflictingAltSubsets(reach);

        if (this.debug) {
          console.log("LL altSubSets=" + altSubSets + ", predict=" + PredictionMode.getUniqueAlt(altSubSets) + ", resolvesToJustOneViableAlt=" + PredictionMode.resolvesToJustOneViableAlt(altSubSets));
        }

        reach.uniqueAlt = this.getUniqueAlt(reach); // unique prediction?

        if (reach.uniqueAlt !== ATN.INVALID_ALT_NUMBER) {
          predictedAlt = reach.uniqueAlt;
          break;
        } else if (this.predictionMode !== PredictionMode.LL_EXACT_AMBIG_DETECTION) {
          predictedAlt = PredictionMode.resolvesToJustOneViableAlt(altSubSets);

          if (predictedAlt !== ATN.INVALID_ALT_NUMBER) {
            break;
          }
        } else {
          // In exact ambiguity mode, we never try to terminate early.
          // Just keeps scarfing until we know what the conflict is
          if (PredictionMode.allSubsetsConflict(altSubSets) && PredictionMode.allSubsetsEqual(altSubSets)) {
            foundExactAmbig = true;
            predictedAlt = PredictionMode.getSingleViableAlt(altSubSets);
            break;
          } // else there are multiple non-conflicting subsets or
          // we're not sure what the ambiguity is yet.
          // So, keep going.

        }

        previous = reach;

        if (t !== Token.EOF) {
          input.consume();
          t = input.LA(1);
        }
      } // If the configuration set uniquely predicts an alternative,
      // without conflict, then we know that it's a full LL decision
      // not SLL.


      if (reach.uniqueAlt !== ATN.INVALID_ALT_NUMBER) {
        this.reportContextSensitivity(dfa, predictedAlt, reach, startIndex, input.index);
        return predictedAlt;
      } // We do not check predicates here because we have checked them
      // on-the-fly when doing full context prediction.
      //
      // In non-exact ambiguity detection mode, we might	actually be able to
      // detect an exact ambiguity, but I'm not going to spend the cycles
      // needed to check. We only emit ambiguity warnings in exact ambiguity
      // mode.
      //
      // For example, we might know that we have conflicting configurations.
      // But, that does not mean that there is no way forward without a
      // conflict. It's possible to have nonconflicting alt subsets as in:
      // altSubSets=[{1, 2}, {1, 2}, {1}, {1, 2}]
      // from
      //
      //    [(17,1,[5 $]), (13,1,[5 10 $]), (21,1,[5 10 $]), (11,1,[$]),
      //     (13,2,[5 10 $]), (21,2,[5 10 $]), (11,2,[$])]
      //
      // In this case, (17,1,[5 $]) indicates there is some next sequence that
      // would resolve this without conflict to alternative 1. Any other viable
      // next sequence, however, is associated with a conflict.  We stop
      // looking for input because no amount of further lookahead will alter
      // the fact that we should predict alternative 1.  We just can't say for
      // sure that there is an ambiguity without looking further.


      this.reportAmbiguity(dfa, D, startIndex, input.index, foundExactAmbig, null, reach);
      return predictedAlt;
    };

    ParserATNSimulator.prototype.computeReachSet = function (closure, t, fullCtx) {
      if (this.debug) {
        console.log("in computeReachSet, starting closure: " + closure);
      }

      if (this.mergeCache === null) {
        this.mergeCache = new DoubleDict();
      }

      var intermediate = new ATNConfigSet(fullCtx); // Configurations already in a rule stop state indicate reaching the end
      // of the decision rule (local context) or end of the start rule (full
      // context). Once reached, these configurations are never updated by a
      // closure operation, so they are handled separately for the performance
      // advantage of having a smaller intermediate set when calling closure.
      //
      // For full-context reach operations, separate handling is required to
      // ensure that the alternative matching the longest overall sequence is
      // chosen when multiple such configurations can match the input.

      var skippedStopStates = null; // First figure out where we can reach on input t

      for (var i = 0; i < closure.items.length; i++) {
        var c = closure.items[i];

        if (this.debug_add) {
          console.log("testing " + this.getTokenName(t) + " at " + c);
        }

        if (c.state instanceof RuleStopState) {
          if (fullCtx || t === Token.EOF) {
            if (skippedStopStates === null) {
              skippedStopStates = [];
            }

            skippedStopStates.push(c);

            if (this.debug_add) {
              console.log("added " + c + " to skippedStopStates");
            }
          }

          continue;
        }

        for (var j = 0; j < c.state.transitions.length; j++) {
          var trans = c.state.transitions[j];
          var target = this.getReachableTarget(trans, t);

          if (target !== null) {
            var cfg = new ATNConfig({
              state: target
            }, c);
            intermediate.add(cfg, this.mergeCache);

            if (this.debug_add) {
              console.log("added " + cfg + " to intermediate");
            }
          }
        }
      } // Now figure out where the reach operation can take us...


      var reach = null; // This block optimizes the reach operation for intermediate sets which
      // trivially indicate a termination state for the overall
      // adaptivePredict operation.
      //
      // The conditions assume that intermediate
      // contains all configurations relevant to the reach set, but this
      // condition is not true when one or more configurations have been
      // withheld in skippedStopStates, or when the current symbol is EOF.
      //

      if (skippedStopStates === null && t !== Token.EOF) {
        if (intermediate.items.length === 1) {
          // Don't pursue the closure if there is just one state.
          // It can only have one alternative; just add to result
          // Also don't pursue the closure if there is unique alternative
          // among the configurations.
          reach = intermediate;
        } else if (this.getUniqueAlt(intermediate) !== ATN.INVALID_ALT_NUMBER) {
          // Also don't pursue the closure if there is unique alternative
          // among the configurations.
          reach = intermediate;
        }
      } // If the reach set could not be trivially determined, perform a closure
      // operation on the intermediate set to compute its initial value.
      //


      if (reach === null) {
        reach = new ATNConfigSet(fullCtx);
        var closureBusy = new Set();
        var treatEofAsEpsilon = t === Token.EOF;

        for (var k = 0; k < intermediate.items.length; k++) {
          this.closure(intermediate.items[k], reach, closureBusy, false, fullCtx, treatEofAsEpsilon);
        }
      }

      if (t === Token.EOF) {
        // After consuming EOF no additional input is possible, so we are
        // only interested in configurations which reached the end of the
        // decision rule (local context) or end of the start rule (full
        // context). Update reach to contain only these configurations. This
        // handles both explicit EOF transitions in the grammar and implicit
        // EOF transitions following the end of the decision or start rule.
        //
        // When reach==intermediate, no closure operation was performed. In
        // this case, removeAllConfigsNotInRuleStopState needs to check for
        // reachable rule stop states as well as configurations already in
        // a rule stop state.
        //
        // This is handled before the configurations in skippedStopStates,
        // because any configurations potentially added from that list are
        // already guaranteed to meet this condition whether or not it's
        // required.
        //
        reach = this.removeAllConfigsNotInRuleStopState(reach, reach === intermediate);
      } // If skippedStopStates!==null, then it contains at least one
      // configuration. For full-context reach operations, these
      // configurations reached the end of the start rule, in which case we
      // only add them back to reach if no configuration during the current
      // closure operation reached such a state. This ensures adaptivePredict
      // chooses an alternative matching the longest overall sequence when
      // multiple alternatives are viable.
      //


      if (skippedStopStates !== null && (!fullCtx || !PredictionMode.hasConfigInRuleStopState(reach))) {
        for (var l = 0; l < skippedStopStates.length; l++) {
          reach.add(skippedStopStates[l], this.mergeCache);
        }
      }

      if (reach.items.length === 0) {
        return null;
      } else {
        return reach;
      }
    }; //
    // Return a configuration set containing only the configurations from
    // {@code configs} which are in a {@link RuleStopState}. If all
    // configurations in {@code configs} are already in a rule stop state, this
    // method simply returns {@code configs}.
    //
    // <p>When {@code lookToEndOfRule} is true, this method uses
    // {@link ATN//nextTokens} for each configuration in {@code configs} which is
    // not already in a rule stop state to see if a rule stop state is reachable
    // from the configuration via epsilon-only transitions.</p>
    //
    // @param configs the configuration set to update
    // @param lookToEndOfRule when true, this method checks for rule stop states
    // reachable by epsilon-only transitions from each configuration in
    // {@code configs}.
    //
    // @return {@code configs} if all configurations in {@code configs} are in a
    // rule stop state, otherwise return a new configuration set containing only
    // the configurations from {@code configs} which are in a rule stop state
    //


    ParserATNSimulator.prototype.removeAllConfigsNotInRuleStopState = function (configs, lookToEndOfRule) {
      if (PredictionMode.allConfigsInRuleStopStates(configs)) {
        return configs;
      }

      var result = new ATNConfigSet(configs.fullCtx);

      for (var i = 0; i < configs.items.length; i++) {
        var config = configs.items[i];

        if (config.state instanceof RuleStopState) {
          result.add(config, this.mergeCache);
          continue;
        }

        if (lookToEndOfRule && config.state.epsilonOnlyTransitions) {
          var nextTokens = this.atn.nextTokens(config.state);

          if (nextTokens.contains(Token.EPSILON)) {
            var endOfRuleState = this.atn.ruleToStopState[config.state.ruleIndex];
            result.add(new ATNConfig({
              state: endOfRuleState
            }, config), this.mergeCache);
          }
        }
      }

      return result;
    };

    ParserATNSimulator.prototype.computeStartState = function (p, ctx, fullCtx) {
      // always at least the implicit call to start rule
      var initialContext = predictionContextFromRuleContext(this.atn, ctx);
      var configs = new ATNConfigSet(fullCtx);

      for (var i = 0; i < p.transitions.length; i++) {
        var target = p.transitions[i].target;
        var c = new ATNConfig({
          state: target,
          alt: i + 1,
          context: initialContext
        }, null);
        var closureBusy = new Set();
        this.closure(c, configs, closureBusy, true, fullCtx, false);
      }

      return configs;
    }; //
    // This method transforms the start state computed by
    // {@link //computeStartState} to the special start state used by a
    // precedence DFA for a particular precedence value. The transformation
    // process applies the following changes to the start state's configuration
    // set.
    //
    // <ol>
    // <li>Evaluate the precedence predicates for each configuration using
    // {@link SemanticContext//evalPrecedence}.</li>
    // <li>Remove all configurations which predict an alternative greater than
    // 1, for which another configuration that predicts alternative 1 is in the
    // same ATN state with the same prediction context. This transformation is
    // valid for the following reasons:
    // <ul>
    // <li>The closure block cannot contain any epsilon transitions which bypass
    // the body of the closure, so all states reachable via alternative 1 are
    // part of the precedence alternatives of the transformed left-recursive
    // rule.</li>
    // <li>The "primary" portion of a left recursive rule cannot contain an
    // epsilon transition, so the only way an alternative other than 1 can exist
    // in a state that is also reachable via alternative 1 is by nesting calls
    // to the left-recursive rule, with the outer calls not being at the
    // preferred precedence level.</li>
    // </ul>
    // </li>
    // </ol>
    //
    // <p>
    // The prediction context must be considered by this filter to address
    // situations like the following.
    // </p>
    // <code>
    // <pre>
    // grammar TA;
    // prog: statement* EOF;
    // statement: letterA | statement letterA 'b' ;
    // letterA: 'a';
    // </pre>
    // </code>
    // <p>
    // If the above grammar, the ATN state immediately before the token
    // reference {@code 'a'} in {@code letterA} is reachable from the left edge
    // of both the primary and closure blocks of the left-recursive rule
    // {@code statement}. The prediction context associated with each of these
    // configurations distinguishes between them, and prevents the alternative
    // which stepped out to {@code prog} (and then back in to {@code statement}
    // from being eliminated by the filter.
    // </p>
    //
    // @param configs The configuration set computed by
    // {@link //computeStartState} as the start state for the DFA.
    // @return The transformed configuration set representing the start state
    // for a precedence DFA at a particular precedence level (determined by
    // calling {@link Parser//getPrecedence}).
    //


    ParserATNSimulator.prototype.applyPrecedenceFilter = function (configs) {
      var config;
      var statesFromAlt1 = [];
      var configSet = new ATNConfigSet(configs.fullCtx);

      for (var i = 0; i < configs.items.length; i++) {
        config = configs.items[i]; // handle alt 1 first

        if (config.alt !== 1) {
          continue;
        }

        var updatedContext = config.semanticContext.evalPrecedence(this.parser, this._outerContext);

        if (updatedContext === null) {
          // the configuration was eliminated
          continue;
        }

        statesFromAlt1[config.state.stateNumber] = config.context;

        if (updatedContext !== config.semanticContext) {
          configSet.add(new ATNConfig({
            semanticContext: updatedContext
          }, config), this.mergeCache);
        } else {
          configSet.add(config, this.mergeCache);
        }
      }

      for (i = 0; i < configs.items.length; i++) {
        config = configs.items[i];

        if (config.alt === 1) {
          // already handled
          continue;
        } // In the future, this elimination step could be updated to also
        // filter the prediction context for alternatives predicting alt>1
        // (basically a graph subtraction algorithm).


        if (!config.precedenceFilterSuppressed) {
          var context = statesFromAlt1[config.state.stateNumber] || null;

          if (context !== null && context.equals(config.context)) {
            // eliminated
            continue;
          }
        }

        configSet.add(config, this.mergeCache);
      }

      return configSet;
    };

    ParserATNSimulator.prototype.getReachableTarget = function (trans, ttype) {
      if (trans.matches(ttype, 0, this.atn.maxTokenType)) {
        return trans.target;
      } else {
        return null;
      }
    };

    ParserATNSimulator.prototype.getPredsForAmbigAlts = function (ambigAlts, configs, nalts) {
      // REACH=[1|1|[]|0:0, 1|2|[]|0:1]
      // altToPred starts as an array of all null contexts. The entry at index i
      // corresponds to alternative i. altToPred[i] may have one of three values:
      //   1. null: no ATNConfig c is found such that c.alt==i
      //   2. SemanticContext.NONE: At least one ATNConfig c exists such that
      //      c.alt==i and c.semanticContext==SemanticContext.NONE. In other words,
      //      alt i has at least one unpredicated config.
      //   3. Non-NONE Semantic Context: There exists at least one, and for all
      //      ATNConfig c such that c.alt==i, c.semanticContext!=SemanticContext.NONE.
      //
      // From this, it is clear that NONE||anything==NONE.
      //
      var altToPred = [];

      for (var i = 0; i < configs.items.length; i++) {
        var c = configs.items[i];

        if (ambigAlts.contains(c.alt)) {
          altToPred[c.alt] = SemanticContext.orContext(altToPred[c.alt] || null, c.semanticContext);
        }
      }

      var nPredAlts = 0;

      for (i = 1; i < nalts + 1; i++) {
        var pred = altToPred[i] || null;

        if (pred === null) {
          altToPred[i] = SemanticContext.NONE;
        } else if (pred !== SemanticContext.NONE) {
          nPredAlts += 1;
        }
      } // nonambig alts are null in altToPred


      if (nPredAlts === 0) {
        altToPred = null;
      }

      if (this.debug) {
        console.log("getPredsForAmbigAlts result " + Utils.arrayToString(altToPred));
      }

      return altToPred;
    };

    ParserATNSimulator.prototype.getPredicatePredictions = function (ambigAlts, altToPred) {
      var pairs = [];
      var containsPredicate = false;

      for (var i = 1; i < altToPred.length; i++) {
        var pred = altToPred[i]; // unpredicated is indicated by SemanticContext.NONE

        if (ambigAlts !== null && ambigAlts.contains(i)) {
          pairs.push(new PredPrediction(pred, i));
        }

        if (pred !== SemanticContext.NONE) {
          containsPredicate = true;
        }
      }

      if (!containsPredicate) {
        return null;
      }

      return pairs;
    }; //
    // This method is used to improve the localization of error messages by
    // choosing an alternative rather than throwing a
    // {@link NoViableAltException} in particular prediction scenarios where the
    // {@link //ERROR} state was reached during ATN simulation.
    //
    // <p>
    // The default implementation of this method uses the following
    // algorithm to identify an ATN configuration which successfully parsed the
    // decision entry rule. Choosing such an alternative ensures that the
    // {@link ParserRuleContext} returned by the calling rule will be complete
    // and valid, and the syntax error will be reported later at a more
    // localized location.</p>
    //
    // <ul>
    // <li>If a syntactically valid path or paths reach the end of the decision rule and
    // they are semantically valid if predicated, return the min associated alt.</li>
    // <li>Else, if a semantically invalid but syntactically valid path exist
    // or paths exist, return the minimum associated alt.
    // </li>
    // <li>Otherwise, return {@link ATN//INVALID_ALT_NUMBER}.</li>
    // </ul>
    //
    // <p>
    // In some scenarios, the algorithm described above could predict an
    // alternative which will result in a {@link FailedPredicateException} in
    // the parser. Specifically, this could occur if the <em>only</em> configuration
    // capable of successfully parsing to the end of the decision rule is
    // blocked by a semantic predicate. By choosing this alternative within
    // {@link //adaptivePredict} instead of throwing a
    // {@link NoViableAltException}, the resulting
    // {@link FailedPredicateException} in the parser will identify the specific
    // predicate which is preventing the parser from successfully parsing the
    // decision rule, which helps developers identify and correct logic errors
    // in semantic predicates.
    // </p>
    //
    // @param configs The ATN configurations which were valid immediately before
    // the {@link //ERROR} state was reached
    // @param outerContext The is the \gamma_0 initial parser context from the paper
    // or the parser stack at the instant before prediction commences.
    //
    // @return The value to return from {@link //adaptivePredict}, or
    // {@link ATN//INVALID_ALT_NUMBER} if a suitable alternative was not
    // identified and {@link //adaptivePredict} should report an error instead.
    //


    ParserATNSimulator.prototype.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule = function (configs, outerContext) {
      var cfgs = this.splitAccordingToSemanticValidity(configs, outerContext);
      var semValidConfigs = cfgs[0];
      var semInvalidConfigs = cfgs[1];
      var alt = this.getAltThatFinishedDecisionEntryRule(semValidConfigs);

      if (alt !== ATN.INVALID_ALT_NUMBER) {
        // semantically/syntactically viable path exists
        return alt;
      } // Is there a syntactically valid path with a failed pred?


      if (semInvalidConfigs.items.length > 0) {
        alt = this.getAltThatFinishedDecisionEntryRule(semInvalidConfigs);

        if (alt !== ATN.INVALID_ALT_NUMBER) {
          // syntactically viable path exists
          return alt;
        }
      }

      return ATN.INVALID_ALT_NUMBER;
    };

    ParserATNSimulator.prototype.getAltThatFinishedDecisionEntryRule = function (configs) {
      var alts = [];

      for (var i = 0; i < configs.items.length; i++) {
        var c = configs.items[i];

        if (c.reachesIntoOuterContext > 0 || c.state instanceof RuleStopState && c.context.hasEmptyPath()) {
          if (alts.indexOf(c.alt) < 0) {
            alts.push(c.alt);
          }
        }
      }

      if (alts.length === 0) {
        return ATN.INVALID_ALT_NUMBER;
      } else {
        return Math.min.apply(null, alts);
      }
    }; // Walk the list of configurations and split them according to
    //  those that have preds evaluating to true/false.  If no pred, assume
    //  true pred and include in succeeded set.  Returns Pair of sets.
    //
    //  Create a new set so as not to alter the incoming parameter.
    //
    //  Assumption: the input stream has been restored to the starting point
    //  prediction, which is where predicates need to evaluate.
    //


    ParserATNSimulator.prototype.splitAccordingToSemanticValidity = function (configs, outerContext) {
      var succeeded = new ATNConfigSet(configs.fullCtx);
      var failed = new ATNConfigSet(configs.fullCtx);

      for (var i = 0; i < configs.items.length; i++) {
        var c = configs.items[i];

        if (c.semanticContext !== SemanticContext.NONE) {
          var predicateEvaluationResult = c.semanticContext.evaluate(this.parser, outerContext);

          if (predicateEvaluationResult) {
            succeeded.add(c);
          } else {
            failed.add(c);
          }
        } else {
          succeeded.add(c);
        }
      }

      return [succeeded, failed];
    }; // Look through a list of predicate/alt pairs, returning alts for the
    //  pairs that win. A {@code NONE} predicate indicates an alt containing an
    //  unpredicated config which behaves as "always true." If !complete
    //  then we stop at the first predicate that evaluates to true. This
    //  includes pairs with null predicates.
    //


    ParserATNSimulator.prototype.evalSemanticContext = function (predPredictions, outerContext, complete) {
      var predictions = new BitSet();

      for (var i = 0; i < predPredictions.length; i++) {
        var pair = predPredictions[i];

        if (pair.pred === SemanticContext.NONE) {
          predictions.add(pair.alt);

          if (!complete) {
            break;
          }

          continue;
        }

        var predicateEvaluationResult = pair.pred.evaluate(this.parser, outerContext);

        if (this.debug || this.dfa_debug) {
          console.log("eval pred " + pair + "=" + predicateEvaluationResult);
        }

        if (predicateEvaluationResult) {
          if (this.debug || this.dfa_debug) {
            console.log("PREDICT " + pair.alt);
          }

          predictions.add(pair.alt);

          if (!complete) {
            break;
          }
        }
      }

      return predictions;
    }; // TODO: If we are doing predicates, there is no point in pursuing
    //     closure operations if we reach a DFA state that uniquely predicts
    //     alternative. We will not be caching that DFA state and it is a
    //     waste to pursue the closure. Might have to advance when we do
    //     ambig detection thought :(
    //


    ParserATNSimulator.prototype.closure = function (config, configs, closureBusy, collectPredicates, fullCtx, treatEofAsEpsilon) {
      var initialDepth = 0;
      this.closureCheckingStopState(config, configs, closureBusy, collectPredicates, fullCtx, initialDepth, treatEofAsEpsilon);
    };

    ParserATNSimulator.prototype.closureCheckingStopState = function (config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon) {
      if (this.debug || this.debug_closure) {
        console.log("closure(" + config.toString(this.parser, true) + ")"); // console.log("configs(" + configs.toString() + ")");

        if (config.reachesIntoOuterContext > 50) {
          throw "problem";
        }
      }

      if (config.state instanceof RuleStopState) {
        // We hit rule end. If we have context info, use it
        // run thru all possible stack tops in ctx
        if (!config.context.isEmpty()) {
          for (var i = 0; i < config.context.length; i++) {
            if (config.context.getReturnState(i) === PredictionContext.EMPTY_RETURN_STATE) {
              if (fullCtx) {
                configs.add(new ATNConfig({
                  state: config.state,
                  context: PredictionContext.EMPTY
                }, config), this.mergeCache);
                continue;
              } else {
                // we have no context info, just chase follow links (if greedy)
                if (this.debug) {
                  console.log("FALLING off rule " + this.getRuleName(config.state.ruleIndex));
                }

                this.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon);
              }

              continue;
            }

            var returnState = this.atn.states[config.context.getReturnState(i)];
            var newContext = config.context.getParent(i); // "pop" return state

            var parms = {
              state: returnState,
              alt: config.alt,
              context: newContext,
              semanticContext: config.semanticContext
            };
            var c = new ATNConfig(parms, null); // While we have context to pop back from, we may have
            // gotten that context AFTER having falling off a rule.
            // Make sure we track that we are now out of context.

            c.reachesIntoOuterContext = config.reachesIntoOuterContext;
            this.closureCheckingStopState(c, configs, closureBusy, collectPredicates, fullCtx, depth - 1, treatEofAsEpsilon);
          }

          return;
        } else if (fullCtx) {
          // reached end of start rule
          configs.add(config, this.mergeCache);
          return;
        } else {
          // else if we have no context info, just chase follow links (if greedy)
          if (this.debug) {
            console.log("FALLING off rule " + this.getRuleName(config.state.ruleIndex));
          }
        }
      }

      this.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon);
    }; // Do the actual work of walking epsilon edges//


    ParserATNSimulator.prototype.closure_ = function (config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon) {
      var p = config.state; // optimization

      if (!p.epsilonOnlyTransitions) {
        configs.add(config, this.mergeCache); // make sure to not return here, because EOF transitions can act as
        // both epsilon transitions and non-epsilon transitions.
      }

      for (var i = 0; i < p.transitions.length; i++) {
        if (i == 0 && this.canDropLoopEntryEdgeInLeftRecursiveRule(config)) continue;
        var t = p.transitions[i];
        var continueCollecting = collectPredicates && !(t instanceof ActionTransition);
        var c = this.getEpsilonTarget(config, t, continueCollecting, depth === 0, fullCtx, treatEofAsEpsilon);

        if (c !== null) {
          if (!t.isEpsilon && closureBusy.add(c) !== c) {
            // avoid infinite recursion for EOF* and EOF+
            continue;
          }

          var newDepth = depth;

          if (config.state instanceof RuleStopState) {
            // target fell off end of rule; mark resulting c as having dipped into outer context
            // We can't get here if incoming config was rule stop and we had context
            // track how far we dip into outer context.  Might
            // come in handy and we avoid evaluating context dependent
            // preds if this is > 0.
            if (closureBusy.add(c) !== c) {
              // avoid infinite recursion for right-recursive rules
              continue;
            }

            if (this._dfa !== null && this._dfa.precedenceDfa) {
              if (t.outermostPrecedenceReturn === this._dfa.atnStartState.ruleIndex) {
                c.precedenceFilterSuppressed = true;
              }
            }

            c.reachesIntoOuterContext += 1;
            configs.dipsIntoOuterContext = true; // TODO: can remove? only care when we add to set per middle of this method

            newDepth -= 1;

            if (this.debug) {
              console.log("dips into outer ctx: " + c);
            }
          } else if (t instanceof RuleTransition) {
            // latch when newDepth goes negative - once we step out of the entry context we can't return
            if (newDepth >= 0) {
              newDepth += 1;
            }
          }

          this.closureCheckingStopState(c, configs, closureBusy, continueCollecting, fullCtx, newDepth, treatEofAsEpsilon);
        }
      }
    };

    ParserATNSimulator.prototype.canDropLoopEntryEdgeInLeftRecursiveRule = function (config) {
      // return False
      var p = config.state; // First check to see if we are in StarLoopEntryState generated during
      // left-recursion elimination. For efficiency, also check if
      // the context has an empty stack case. If so, it would mean
      // global FOLLOW so we can't perform optimization
      // Are we the special loop entry/exit state? or SLL wildcard

      if (p.stateType != ATNState.STAR_LOOP_ENTRY) return false;
      if (p.stateType != ATNState.STAR_LOOP_ENTRY || !p.isPrecedenceDecision || config.context.isEmpty() || config.context.hasEmptyPath()) return false; // Require all return states to return back to the same rule that p is in.

      var numCtxs = config.context.length;

      for (var i = 0; i < numCtxs; i++) {
        // for each stack context
        var returnState = this.atn.states[config.context.getReturnState(i)];
        if (returnState.ruleIndex != p.ruleIndex) return false;
      }

      var decisionStartState = p.transitions[0].target;
      var blockEndStateNum = decisionStartState.endState.stateNumber;
      var blockEndState = this.atn.states[blockEndStateNum]; // Verify that the top of each stack context leads to loop entry/exit
      // state through epsilon edges and w/o leaving rule.

      for (var i = 0; i < numCtxs; i++) {
        // for each stack context
        var returnStateNumber = config.context.getReturnState(i);
        var returnState = this.atn.states[returnStateNumber]; // all states must have single outgoing epsilon edge

        if (returnState.transitions.length != 1 || !returnState.transitions[0].isEpsilon) return false; // Look for prefix op case like 'not expr', (' type ')' expr

        var returnStateTarget = returnState.transitions[0].target;
        if (returnState.stateType == ATNState.BLOCK_END && returnStateTarget == p) continue; // Look for 'expr op expr' or case where expr's return state is block end
        // of (...)* internal block; the block end points to loop back
        // which points to p but we don't need to check that

        if (returnState == blockEndState) continue; // Look for ternary expr ? expr : expr. The return state points at block end,
        // which points at loop entry state

        if (returnStateTarget == blockEndState) continue; // Look for complex prefix 'between expr and expr' case where 2nd expr's
        // return state points at block end state of (...)* internal block

        if (returnStateTarget.stateType == ATNState.BLOCK_END && returnStateTarget.transitions.length == 1 && returnStateTarget.transitions[0].isEpsilon && returnStateTarget.transitions[0].target == p) continue; // anything else ain't conforming

        return false;
      }

      return true;
    };

    ParserATNSimulator.prototype.getRuleName = function (index) {
      if (this.parser !== null && index >= 0) {
        return this.parser.ruleNames[index];
      } else {
        return "<rule " + index + ">";
      }
    };

    ParserATNSimulator.prototype.getEpsilonTarget = function (config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon) {
      switch (t.serializationType) {
        case Transition.RULE:
          return this.ruleTransition(config, t);

        case Transition.PRECEDENCE:
          return this.precedenceTransition(config, t, collectPredicates, inContext, fullCtx);

        case Transition.PREDICATE:
          return this.predTransition(config, t, collectPredicates, inContext, fullCtx);

        case Transition.ACTION:
          return this.actionTransition(config, t);

        case Transition.EPSILON:
          return new ATNConfig({
            state: t.target
          }, config);

        case Transition.ATOM:
        case Transition.RANGE:
        case Transition.SET:
          // EOF transitions act like epsilon transitions after the first EOF
          // transition is traversed
          if (treatEofAsEpsilon) {
            if (t.matches(Token.EOF, 0, 1)) {
              return new ATNConfig({
                state: t.target
              }, config);
            }
          }

          return null;

        default:
          return null;
      }
    };

    ParserATNSimulator.prototype.actionTransition = function (config, t) {
      if (this.debug) {
        var index = t.actionIndex == -1 ? 65535 : t.actionIndex;
        console.log("ACTION edge " + t.ruleIndex + ":" + index);
      }

      return new ATNConfig({
        state: t.target
      }, config);
    };

    ParserATNSimulator.prototype.precedenceTransition = function (config, pt, collectPredicates, inContext, fullCtx) {
      if (this.debug) {
        console.log("PRED (collectPredicates=" + collectPredicates + ") " + pt.precedence + ">=_p, ctx dependent=true");

        if (this.parser !== null) {
          console.log("context surrounding pred is " + Utils.arrayToString(this.parser.getRuleInvocationStack()));
        }
      }

      var c = null;

      if (collectPredicates && inContext) {
        if (fullCtx) {
          // In full context mode, we can evaluate predicates on-the-fly
          // during closure, which dramatically reduces the size of
          // the config sets. It also obviates the need to test predicates
          // later during conflict resolution.
          var currentPosition = this._input.index;

          this._input.seek(this._startIndex);

          var predSucceeds = pt.getPredicate().evaluate(this.parser, this._outerContext);

          this._input.seek(currentPosition);

          if (predSucceeds) {
            c = new ATNConfig({
              state: pt.target
            }, config); // no pred context
          }
        } else {
          var newSemCtx = SemanticContext.andContext(config.semanticContext, pt.getPredicate());
          c = new ATNConfig({
            state: pt.target,
            semanticContext: newSemCtx
          }, config);
        }
      } else {
        c = new ATNConfig({
          state: pt.target
        }, config);
      }

      if (this.debug) {
        console.log("config from pred transition=" + c);
      }

      return c;
    };

    ParserATNSimulator.prototype.predTransition = function (config, pt, collectPredicates, inContext, fullCtx) {
      if (this.debug) {
        console.log("PRED (collectPredicates=" + collectPredicates + ") " + pt.ruleIndex + ":" + pt.predIndex + ", ctx dependent=" + pt.isCtxDependent);

        if (this.parser !== null) {
          console.log("context surrounding pred is " + Utils.arrayToString(this.parser.getRuleInvocationStack()));
        }
      }

      var c = null;

      if (collectPredicates && (pt.isCtxDependent && inContext || !pt.isCtxDependent)) {
        if (fullCtx) {
          // In full context mode, we can evaluate predicates on-the-fly
          // during closure, which dramatically reduces the size of
          // the config sets. It also obviates the need to test predicates
          // later during conflict resolution.
          var currentPosition = this._input.index;

          this._input.seek(this._startIndex);

          var predSucceeds = pt.getPredicate().evaluate(this.parser, this._outerContext);

          this._input.seek(currentPosition);

          if (predSucceeds) {
            c = new ATNConfig({
              state: pt.target
            }, config); // no pred context
          }
        } else {
          var newSemCtx = SemanticContext.andContext(config.semanticContext, pt.getPredicate());
          c = new ATNConfig({
            state: pt.target,
            semanticContext: newSemCtx
          }, config);
        }
      } else {
        c = new ATNConfig({
          state: pt.target
        }, config);
      }

      if (this.debug) {
        console.log("config from pred transition=" + c);
      }

      return c;
    };

    ParserATNSimulator.prototype.ruleTransition = function (config, t) {
      if (this.debug) {
        console.log("CALL rule " + this.getRuleName(t.target.ruleIndex) + ", ctx=" + config.context);
      }

      var returnState = t.followState;
      var newContext = SingletonPredictionContext.create(config.context, returnState.stateNumber);
      return new ATNConfig({
        state: t.target,
        context: newContext
      }, config);
    };

    ParserATNSimulator.prototype.getConflictingAlts = function (configs) {
      var altsets = PredictionMode.getConflictingAltSubsets(configs);
      return PredictionMode.getAlts(altsets);
    }; // Sam pointed out a problem with the previous definition, v3, of
    // ambiguous states. If we have another state associated with conflicting
    // alternatives, we should keep going. For example, the following grammar
    //
    // s : (ID | ID ID?) ';' ;
    //
    // When the ATN simulation reaches the state before ';', it has a DFA
    // state that looks like: [12|1|[], 6|2|[], 12|2|[]]. Naturally
    // 12|1|[] and 12|2|[] conflict, but we cannot stop processing this node
    // because alternative to has another way to continue, via [6|2|[]].
    // The key is that we have a single state that has config's only associated
    // with a single alternative, 2, and crucially the state transitions
    // among the configurations are all non-epsilon transitions. That means
    // we don't consider any conflicts that include alternative 2. So, we
    // ignore the conflict between alts 1 and 2. We ignore a set of
    // conflicting alts when there is an intersection with an alternative
    // associated with a single alt state in the state&rarr;config-list map.
    //
    // It's also the case that we might have two conflicting configurations but
    // also a 3rd nonconflicting configuration for a different alternative:
    // [1|1|[], 1|2|[], 8|3|[]]. This can come about from grammar:
    //
    // a : A | A | A B ;
    //
    // After matching input A, we reach the stop state for rule A, state 1.
    // State 8 is the state right before B. Clearly alternatives 1 and 2
    // conflict and no amount of further lookahead will separate the two.
    // However, alternative 3 will be able to continue and so we do not
    // stop working on this state. In the previous example, we're concerned
    // with states associated with the conflicting alternatives. Here alt
    // 3 is not associated with the conflicting configs, but since we can continue
    // looking for input reasonably, I don't declare the state done. We
    // ignore a set of conflicting alts when we have an alternative
    // that we still need to pursue.
    //


    ParserATNSimulator.prototype.getConflictingAltsOrUniqueAlt = function (configs) {
      var conflictingAlts = null;

      if (configs.uniqueAlt !== ATN.INVALID_ALT_NUMBER) {
        conflictingAlts = new BitSet();
        conflictingAlts.add(configs.uniqueAlt);
      } else {
        conflictingAlts = configs.conflictingAlts;
      }

      return conflictingAlts;
    };

    ParserATNSimulator.prototype.getTokenName = function (t) {
      if (t === Token.EOF) {
        return "EOF";
      }

      if (this.parser !== null && this.parser.literalNames !== null) {
        if (t >= this.parser.literalNames.length && t >= this.parser.symbolicNames.length) {
          console.log("" + t + " ttype out of range: " + this.parser.literalNames);
          console.log("" + this.parser.getInputStream().getTokens());
        } else {
          var name = this.parser.literalNames[t] || this.parser.symbolicNames[t];
          return name + "<" + t + ">";
        }
      }

      return "" + t;
    };

    ParserATNSimulator.prototype.getLookaheadName = function (input) {
      return this.getTokenName(input.LA(1));
    }; // Used for debugging in adaptivePredict around execATN but I cut
    //  it out for clarity now that alg. works well. We can leave this
    //  "dead" code for a bit.
    //


    ParserATNSimulator.prototype.dumpDeadEndConfigs = function (nvae) {
      console.log("dead end configs: ");
      var decs = nvae.getDeadEndConfigs();

      for (var i = 0; i < decs.length; i++) {
        var c = decs[i];
        var trans = "no edges";

        if (c.state.transitions.length > 0) {
          var t = c.state.transitions[0];

          if (t instanceof AtomTransition) {
            trans = "Atom " + this.getTokenName(t.label);
          } else if (t instanceof SetTransition) {
            var neg = t instanceof NotSetTransition;
            trans = (neg ? "~" : "") + "Set " + t.set;
          }
        }

        console.error(c.toString(this.parser, true) + ":" + trans);
      }
    };

    ParserATNSimulator.prototype.noViableAlt = function (input, outerContext, configs, startIndex) {
      return new NoViableAltException(this.parser, input, input.get(startIndex), input.LT(1), configs, outerContext);
    };

    ParserATNSimulator.prototype.getUniqueAlt = function (configs) {
      var alt = ATN.INVALID_ALT_NUMBER;

      for (var i = 0; i < configs.items.length; i++) {
        var c = configs.items[i];

        if (alt === ATN.INVALID_ALT_NUMBER) {
          alt = c.alt; // found first alt
        } else if (c.alt !== alt) {
          return ATN.INVALID_ALT_NUMBER;
        }
      }

      return alt;
    }; //
    // Add an edge to the DFA, if possible. This method calls
    // {@link //addDFAState} to ensure the {@code to} state is present in the
    // DFA. If {@code from} is {@code null}, or if {@code t} is outside the
    // range of edges that can be represented in the DFA tables, this method
    // returns without adding the edge to the DFA.
    //
    // <p>If {@code to} is {@code null}, this method returns {@code null}.
    // Otherwise, this method returns the {@link DFAState} returned by calling
    // {@link //addDFAState} for the {@code to} state.</p>
    //
    // @param dfa The DFA
    // @param from The source state for the edge
    // @param t The input symbol
    // @param to The target state for the edge
    //
    // @return If {@code to} is {@code null}, this method returns {@code null};
    // otherwise this method returns the result of calling {@link //addDFAState}
    // on {@code to}
    //


    ParserATNSimulator.prototype.addDFAEdge = function (dfa, from_, t, to) {
      if (this.debug) {
        console.log("EDGE " + from_ + " -> " + to + " upon " + this.getTokenName(t));
      }

      if (to === null) {
        return null;
      }

      to = this.addDFAState(dfa, to); // used existing if possible not incoming

      if (from_ === null || t < -1 || t > this.atn.maxTokenType) {
        return to;
      }

      if (from_.edges === null) {
        from_.edges = [];
      }

      from_.edges[t + 1] = to; // connect

      if (this.debug) {
        var literalNames = this.parser === null ? null : this.parser.literalNames;
        var symbolicNames = this.parser === null ? null : this.parser.symbolicNames;
        console.log("DFA=\n" + dfa.toString(literalNames, symbolicNames));
      }

      return to;
    }; //
    // Add state {@code D} to the DFA if it is not already present, and return
    // the actual instance stored in the DFA. If a state equivalent to {@code D}
    // is already in the DFA, the existing state is returned. Otherwise this
    // method returns {@code D} after adding it to the DFA.
    //
    // <p>If {@code D} is {@link //ERROR}, this method returns {@link //ERROR} and
    // does not change the DFA.</p>
    //
    // @param dfa The dfa
    // @param D The DFA state to add
    // @return The state stored in the DFA. This will be either the existing
    // state if {@code D} is already in the DFA, or {@code D} itself if the
    // state was not already present.
    //


    ParserATNSimulator.prototype.addDFAState = function (dfa, D) {
      if (D == ATNSimulator.ERROR) {
        return D;
      }

      var existing = dfa.states.get(D);

      if (existing !== null) {
        return existing;
      }

      D.stateNumber = dfa.states.length;

      if (!D.configs.readOnly) {
        D.configs.optimizeConfigs(this);
        D.configs.setReadonly(true);
      }

      dfa.states.add(D);

      if (this.debug) {
        console.log("adding new DFA state: " + D);
      }

      return D;
    };

    ParserATNSimulator.prototype.reportAttemptingFullContext = function (dfa, conflictingAlts, configs, startIndex, stopIndex) {
      if (this.debug || this.retry_debug) {
        var interval = new Interval(startIndex, stopIndex + 1);
        console.log("reportAttemptingFullContext decision=" + dfa.decision + ":" + configs + ", input=" + this.parser.getTokenStream().getText(interval));
      }

      if (this.parser !== null) {
        this.parser.getErrorListenerDispatch().reportAttemptingFullContext(this.parser, dfa, startIndex, stopIndex, conflictingAlts, configs);
      }
    };

    ParserATNSimulator.prototype.reportContextSensitivity = function (dfa, prediction, configs, startIndex, stopIndex) {
      if (this.debug || this.retry_debug) {
        var interval = new Interval(startIndex, stopIndex + 1);
        console.log("reportContextSensitivity decision=" + dfa.decision + ":" + configs + ", input=" + this.parser.getTokenStream().getText(interval));
      }

      if (this.parser !== null) {
        this.parser.getErrorListenerDispatch().reportContextSensitivity(this.parser, dfa, startIndex, stopIndex, prediction, configs);
      }
    }; // If context sensitive parsing, we know it's ambiguity not conflict//


    ParserATNSimulator.prototype.reportAmbiguity = function (dfa, D, startIndex, stopIndex, exact, ambigAlts, configs) {
      if (this.debug || this.retry_debug) {
        var interval = new Interval(startIndex, stopIndex + 1);
        console.log("reportAmbiguity " + ambigAlts + ":" + configs + ", input=" + this.parser.getTokenStream().getText(interval));
      }

      if (this.parser !== null) {
        this.parser.getErrorListenerDispatch().reportAmbiguity(this.parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
      }
    };

    exports.ParserATNSimulator = ParserATNSimulator;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/PredictionMode.js":
  /*!***************************************************!*\
    !*** ./node_modules/antlr4/atn/PredictionMode.js ***!
    \***************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_PredictionModeJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    //
    // This enumeration defines the prediction modes available in ANTLR 4 along with
    // utility methods for analyzing configuration sets for conflicts and/or
    // ambiguities.
    var Set = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js").Set;

    var Map = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js").Map;

    var BitSet = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js").BitSet;

    var AltDict = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js").AltDict;

    var ATN = __webpack_require__(
    /*! ./ATN */
    "./node_modules/antlr4/atn/ATN.js").ATN;

    var RuleStopState = __webpack_require__(
    /*! ./ATNState */
    "./node_modules/antlr4/atn/ATNState.js").RuleStopState;

    var ATNConfigSet = __webpack_require__(
    /*! ./ATNConfigSet */
    "./node_modules/antlr4/atn/ATNConfigSet.js").ATNConfigSet;

    var ATNConfig = __webpack_require__(
    /*! ./ATNConfig */
    "./node_modules/antlr4/atn/ATNConfig.js").ATNConfig;

    var SemanticContext = __webpack_require__(
    /*! ./SemanticContext */
    "./node_modules/antlr4/atn/SemanticContext.js").SemanticContext;

    var Hash = __webpack_require__(
    /*! ../Utils */
    "./node_modules/antlr4/Utils.js").Hash;

    var hashStuff = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js").hashStuff;

    var equalArrays = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js").equalArrays;

    function PredictionMode() {
      return this;
    } //
    // The SLL(*) prediction mode. This prediction mode ignores the current
    // parser context when making predictions. This is the fastest prediction
    // mode, and provides correct results for many grammars. This prediction
    // mode is more powerful than the prediction mode provided by ANTLR 3, but
    // may result in syntax errors for grammar and input combinations which are
    // not SLL.
    //
    // <p>
    // When using this prediction mode, the parser will either return a correct
    // parse tree (i.e. the same parse tree that would be returned with the
    // {@link //LL} prediction mode), or it will report a syntax error. If a
    // syntax error is encountered when using the {@link //SLL} prediction mode,
    // it may be due to either an actual syntax error in the input or indicate
    // that the particular combination of grammar and input requires the more
    // powerful {@link //LL} prediction abilities to complete successfully.</p>
    //
    // <p>
    // This prediction mode does not provide any guarantees for prediction
    // behavior for syntactically-incorrect inputs.</p>
    //


    PredictionMode.SLL = 0; //
    // The LL(*) prediction mode. This prediction mode allows the current parser
    // context to be used for resolving SLL conflicts that occur during
    // prediction. This is the fastest prediction mode that guarantees correct
    // parse results for all combinations of grammars with syntactically correct
    // inputs.
    //
    // <p>
    // When using this prediction mode, the parser will make correct decisions
    // for all syntactically-correct grammar and input combinations. However, in
    // cases where the grammar is truly ambiguous this prediction mode might not
    // report a precise answer for <em>exactly which</em> alternatives are
    // ambiguous.</p>
    //
    // <p>
    // This prediction mode does not provide any guarantees for prediction
    // behavior for syntactically-incorrect inputs.</p>
    //

    PredictionMode.LL = 1; //
    // The LL(*) prediction mode with exact ambiguity detection. In addition to
    // the correctness guarantees provided by the {@link //LL} prediction mode,
    // this prediction mode instructs the prediction algorithm to determine the
    // complete and exact set of ambiguous alternatives for every ambiguous
    // decision encountered while parsing.
    //
    // <p>
    // This prediction mode may be used for diagnosing ambiguities during
    // grammar development. Due to the performance overhead of calculating sets
    // of ambiguous alternatives, this prediction mode should be avoided when
    // the exact results are not necessary.</p>
    //
    // <p>
    // This prediction mode does not provide any guarantees for prediction
    // behavior for syntactically-incorrect inputs.</p>
    //

    PredictionMode.LL_EXACT_AMBIG_DETECTION = 2; //
    // Computes the SLL prediction termination condition.
    //
    // <p>
    // This method computes the SLL prediction termination condition for both of
    // the following cases.</p>
    //
    // <ul>
    // <li>The usual SLL+LL fallback upon SLL conflict</li>
    // <li>Pure SLL without LL fallback</li>
    // </ul>
    //
    // <p><strong>COMBINED SLL+LL PARSING</strong></p>
    //
    // <p>When LL-fallback is enabled upon SLL conflict, correct predictions are
    // ensured regardless of how the termination condition is computed by this
    // method. Due to the substantially higher cost of LL prediction, the
    // prediction should only fall back to LL when the additional lookahead
    // cannot lead to a unique SLL prediction.</p>
    //
    // <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
    // conflicting subsets should fall back to full LL, even if the
    // configuration sets don't resolve to the same alternative (e.g.
    // {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting
    // configuration, SLL could continue with the hopes that more lookahead will
    // resolve via one of those non-conflicting configurations.</p>
    //
    // <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)
    // stops when it sees only conflicting configuration subsets. In contrast,
    // full LL keeps going when there is uncertainty.</p>
    //
    // <p><strong>HEURISTIC</strong></p>
    //
    // <p>As a heuristic, we stop prediction when we see any conflicting subset
    // unless we see a state that only has one alternative associated with it.
    // The single-alt-state thing lets prediction continue upon rules like
    // (otherwise, it would admit defeat too soon):</p>
    //
    // <p>{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}</p>
    //
    // <p>When the ATN simulation reaches the state before {@code ';'}, it has a
    // DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally
    // {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop
    // processing this node because alternative to has another way to continue,
    // via {@code [6|2|[]]}.</p>
    //
    // <p>It also let's us continue for this rule:</p>
    //
    // <p>{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}</p>
    //
    // <p>After matching input A, we reach the stop state for rule A, state 1.
    // State 8 is the state right before B. Clearly alternatives 1 and 2
    // conflict and no amount of further lookahead will separate the two.
    // However, alternative 3 will be able to continue and so we do not stop
    // working on this state. In the previous example, we're concerned with
    // states associated with the conflicting alternatives. Here alt 3 is not
    // associated with the conflicting configs, but since we can continue
    // looking for input reasonably, don't declare the state done.</p>
    //
    // <p><strong>PURE SLL PARSING</strong></p>
    //
    // <p>To handle pure SLL parsing, all we have to do is make sure that we
    // combine stack contexts for configurations that differ only by semantic
    // predicate. From there, we can do the usual SLL termination heuristic.</p>
    //
    // <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>
    //
    // <p>SLL decisions don't evaluate predicates until after they reach DFA stop
    // states because they need to create the DFA cache that works in all
    // semantic situations. In contrast, full LL evaluates predicates collected
    // during start state computation so it can ignore predicates thereafter.
    // This means that SLL termination detection can totally ignore semantic
    // predicates.</p>
    //
    // <p>Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
    // semantic predicate contexts so we might see two configurations like the
    // following.</p>
    //
    // <p>{@code (s, 1, x, {}), (s, 1, x', {p})}</p>
    //
    // <p>Before testing these configurations against others, we have to merge
    // {@code x} and {@code x'} (without modifying the existing configurations).
    // For example, we test {@code (x+x')==x''} when looking for conflicts in
    // the following configurations.</p>
    //
    // <p>{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}</p>
    //
    // <p>If the configuration set has predicates (as indicated by
    // {@link ATNConfigSet//hasSemanticContext}), this algorithm makes a copy of
    // the configurations to strip out all of the predicates so that a standard
    // {@link ATNConfigSet} will merge everything ignoring predicates.</p>
    //

    PredictionMode.hasSLLConflictTerminatingPrediction = function (mode, configs) {
      // Configs in rule stop states indicate reaching the end of the decision
      // rule (local context) or end of start rule (full context). If all
      // configs meet this condition, then none of the configurations is able
      // to match additional input so we terminate prediction.
      //
      if (PredictionMode.allConfigsInRuleStopStates(configs)) {
        return true;
      } // pure SLL mode parsing


      if (mode === PredictionMode.SLL) {
        // Don't bother with combining configs from different semantic
        // contexts if we can fail over to full LL; costs more time
        // since we'll often fail over anyway.
        if (configs.hasSemanticContext) {
          // dup configs, tossing out semantic predicates
          var dup = new ATNConfigSet();

          for (var i = 0; i < configs.items.length; i++) {
            var c = configs.items[i];
            c = new ATNConfig({
              semanticContext: SemanticContext.NONE
            }, c);
            dup.add(c);
          }

          configs = dup;
        } // now we have combined contexts for configs with dissimilar preds

      } // pure SLL or combined SLL+LL mode parsing


      var altsets = PredictionMode.getConflictingAltSubsets(configs);
      return PredictionMode.hasConflictingAltSet(altsets) && !PredictionMode.hasStateAssociatedWithOneAlt(configs);
    }; // Checks if any configuration in {@code configs} is in a
    // {@link RuleStopState}. Configurations meeting this condition have reached
    // the end of the decision rule (local context) or end of start rule (full
    // context).
    //
    // @param configs the configuration set to test
    // @return {@code true} if any configuration in {@code configs} is in a
    // {@link RuleStopState}, otherwise {@code false}


    PredictionMode.hasConfigInRuleStopState = function (configs) {
      for (var i = 0; i < configs.items.length; i++) {
        var c = configs.items[i];

        if (c.state instanceof RuleStopState) {
          return true;
        }
      }

      return false;
    }; // Checks if all configurations in {@code configs} are in a
    // {@link RuleStopState}. Configurations meeting this condition have reached
    // the end of the decision rule (local context) or end of start rule (full
    // context).
    //
    // @param configs the configuration set to test
    // @return {@code true} if all configurations in {@code configs} are in a
    // {@link RuleStopState}, otherwise {@code false}


    PredictionMode.allConfigsInRuleStopStates = function (configs) {
      for (var i = 0; i < configs.items.length; i++) {
        var c = configs.items[i];

        if (!(c.state instanceof RuleStopState)) {
          return false;
        }
      }

      return true;
    }; //
    // Full LL prediction termination.
    //
    // <p>Can we stop looking ahead during ATN simulation or is there some
    // uncertainty as to which alternative we will ultimately pick, after
    // consuming more input? Even if there are partial conflicts, we might know
    // that everything is going to resolve to the same minimum alternative. That
    // means we can stop since no more lookahead will change that fact. On the
    // other hand, there might be multiple conflicts that resolve to different
    // minimums. That means we need more look ahead to decide which of those
    // alternatives we should predict.</p>
    //
    // <p>The basic idea is to split the set of configurations {@code C}, into
    // conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with
    // non-conflicting configurations. Two configurations conflict if they have
    // identical {@link ATNConfig//state} and {@link ATNConfig//context} values
    // but different {@link ATNConfig//alt} value, e.g. {@code (s, i, ctx, _)}
    // and {@code (s, j, ctx, _)} for {@code i!=j}.</p>
    //
    // <p>Reduce these configuration subsets to the set of possible alternatives.
    // You can compute the alternative subsets in one pass as follows:</p>
    //
    // <p>{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in
    // {@code C} holding {@code s} and {@code ctx} fixed.</p>
    //
    // <p>Or in pseudo-code, for each configuration {@code c} in {@code C}:</p>
    //
    // <pre>
    // map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not
    // alt and not pred
    // </pre>
    //
    // <p>The values in {@code map} are the set of {@code A_s,ctx} sets.</p>
    //
    // <p>If {@code |A_s,ctx|=1} then there is no conflict associated with
    // {@code s} and {@code ctx}.</p>
    //
    // <p>Reduce the subsets to singletons by choosing a minimum of each subset. If
    // the union of these alternative subsets is a singleton, then no amount of
    // more lookahead will help us. We will always pick that alternative. If,
    // however, there is more than one alternative, then we are uncertain which
    // alternative to predict and must continue looking for resolution. We may
    // or may not discover an ambiguity in the future, even if there are no
    // conflicting subsets this round.</p>
    //
    // <p>The biggest sin is to terminate early because it means we've made a
    // decision but were uncertain as to the eventual outcome. We haven't used
    // enough lookahead. On the other hand, announcing a conflict too late is no
    // big deal; you will still have the conflict. It's just inefficient. It
    // might even look until the end of file.</p>
    //
    // <p>No special consideration for semantic predicates is required because
    // predicates are evaluated on-the-fly for full LL prediction, ensuring that
    // no configuration contains a semantic context during the termination
    // check.</p>
    //
    // <p><strong>CONFLICTING CONFIGS</strong></p>
    //
    // <p>Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict
    // when {@code i!=j} but {@code x=x'}. Because we merge all
    // {@code (s, i, _)} configurations together, that means that there are at
    // most {@code n} configurations associated with state {@code s} for
    // {@code n} possible alternatives in the decision. The merged stacks
    // complicate the comparison of configuration contexts {@code x} and
    // {@code x'}. Sam checks to see if one is a subset of the other by calling
    // merge and checking to see if the merged result is either {@code x} or
    // {@code x'}. If the {@code x} associated with lowest alternative {@code i}
    // is the superset, then {@code i} is the only possible prediction since the
    // others resolve to {@code min(i)} as well. However, if {@code x} is
    // associated with {@code j>i} then at least one stack configuration for
    // {@code j} is not in conflict with alternative {@code i}. The algorithm
    // should keep going, looking for more lookahead due to the uncertainty.</p>
    //
    // <p>For simplicity, I'm doing a equality check between {@code x} and
    // {@code x'} that lets the algorithm continue to consume lookahead longer
    // than necessary. The reason I like the equality is of course the
    // simplicity but also because that is the test you need to detect the
    // alternatives that are actually in conflict.</p>
    //
    // <p><strong>CONTINUE/STOP RULE</strong></p>
    //
    // <p>Continue if union of resolved alternative sets from non-conflicting and
    // conflicting alternative subsets has more than one alternative. We are
    // uncertain about which alternative to predict.</p>
    //
    // <p>The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which
    // alternatives are still in the running for the amount of input we've
    // consumed at this point. The conflicting sets let us to strip away
    // configurations that won't lead to more states because we resolve
    // conflicts to the configuration with a minimum alternate for the
    // conflicting set.</p>
    //
    // <p><strong>CASES</strong></p>
    //
    // <ul>
    //
    // <li>no conflicts and more than 1 alternative in set =&gt; continue</li>
    //
    // <li> {@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s, 3, z)},
    // {@code (s', 1, y)}, {@code (s', 2, y)} yields non-conflicting set
    // {@code {3}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
    // {@code {1,3}} =&gt; continue
    // </li>
    //
    // <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
    // {@code (s', 2, y)}, {@code (s'', 1, z)} yields non-conflicting set
    // {@code {1}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
    // {@code {1}} =&gt; stop and predict 1</li>
    //
    // <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
    // {@code (s', 2, y)} yields conflicting, reduced sets {@code {1}} U
    // {@code {1}} = {@code {1}} =&gt; stop and predict 1, can announce
    // ambiguity {@code {1,2}}</li>
    //
    // <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 2, y)},
    // {@code (s', 3, y)} yields conflicting, reduced sets {@code {1}} U
    // {@code {2}} = {@code {1,2}} =&gt; continue</li>
    //
    // <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 3, y)},
    // {@code (s', 4, y)} yields conflicting, reduced sets {@code {1}} U
    // {@code {3}} = {@code {1,3}} =&gt; continue</li>
    //
    // </ul>
    //
    // <p><strong>EXACT AMBIGUITY DETECTION</strong></p>
    //
    // <p>If all states report the same conflicting set of alternatives, then we
    // know we have the exact ambiguity set.</p>
    //
    // <p><code>|A_<em>i</em>|&gt;1</code> and
    // <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>
    //
    // <p>In other words, we continue examining lookahead until all {@code A_i}
    // have more than one alternative and all {@code A_i} are the same. If
    // {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate
    // because the resolved set is {@code {1}}. To determine what the real
    // ambiguity is, we have to know whether the ambiguity is between one and
    // two or one and three so we keep going. We can only stop prediction when
    // we need exact ambiguity detection when the sets look like
    // {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...</p>
    //


    PredictionMode.resolvesToJustOneViableAlt = function (altsets) {
      return PredictionMode.getSingleViableAlt(altsets);
    }; //
    // Determines if every alternative subset in {@code altsets} contains more
    // than one alternative.
    //
    // @param altsets a collection of alternative subsets
    // @return {@code true} if every {@link BitSet} in {@code altsets} has
    // {@link BitSet//cardinality cardinality} &gt; 1, otherwise {@code false}
    //


    PredictionMode.allSubsetsConflict = function (altsets) {
      return !PredictionMode.hasNonConflictingAltSet(altsets);
    }; //
    // Determines if any single alternative subset in {@code altsets} contains
    // exactly one alternative.
    //
    // @param altsets a collection of alternative subsets
    // @return {@code true} if {@code altsets} contains a {@link BitSet} with
    // {@link BitSet//cardinality cardinality} 1, otherwise {@code false}
    //


    PredictionMode.hasNonConflictingAltSet = function (altsets) {
      for (var i = 0; i < altsets.length; i++) {
        var alts = altsets[i];

        if (alts.length === 1) {
          return true;
        }
      }

      return false;
    }; //
    // Determines if any single alternative subset in {@code altsets} contains
    // more than one alternative.
    //
    // @param altsets a collection of alternative subsets
    // @return {@code true} if {@code altsets} contains a {@link BitSet} with
    // {@link BitSet//cardinality cardinality} &gt; 1, otherwise {@code false}
    //


    PredictionMode.hasConflictingAltSet = function (altsets) {
      for (var i = 0; i < altsets.length; i++) {
        var alts = altsets[i];

        if (alts.length > 1) {
          return true;
        }
      }

      return false;
    }; //
    // Determines if every alternative subset in {@code altsets} is equivalent.
    //
    // @param altsets a collection of alternative subsets
    // @return {@code true} if every member of {@code altsets} is equal to the
    // others, otherwise {@code false}
    //


    PredictionMode.allSubsetsEqual = function (altsets) {
      var first = null;

      for (var i = 0; i < altsets.length; i++) {
        var alts = altsets[i];

        if (first === null) {
          first = alts;
        } else if (alts !== first) {
          return false;
        }
      }

      return true;
    }; //
    // Returns the unique alternative predicted by all alternative subsets in
    // {@code altsets}. If no such alternative exists, this method returns
    // {@link ATN//INVALID_ALT_NUMBER}.
    //
    // @param altsets a collection of alternative subsets
    //


    PredictionMode.getUniqueAlt = function (altsets) {
      var all = PredictionMode.getAlts(altsets);

      if (all.length === 1) {
        return all.minValue();
      } else {
        return ATN.INVALID_ALT_NUMBER;
      }
    }; // Gets the complete set of represented alternatives for a collection of
    // alternative subsets. This method returns the union of each {@link BitSet}
    // in {@code altsets}.
    //
    // @param altsets a collection of alternative subsets
    // @return the set of represented alternatives in {@code altsets}
    //


    PredictionMode.getAlts = function (altsets) {
      var all = new BitSet();
      altsets.map(function (alts) {
        all.or(alts);
      });
      return all;
    }; //
    // This function gets the conflicting alt subsets from a configuration set.
    // For each configuration {@code c} in {@code configs}:
    //
    // <pre>
    // map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not
    // alt and not pred
    // </pre>


    PredictionMode.getConflictingAltSubsets = function (configs) {
      var configToAlts = new Map();

      configToAlts.hashFunction = function (cfg) {
        hashStuff(cfg.state.stateNumber, cfg.context);
      };

      configToAlts.equalsFunction = function (c1, c2) {
        return c1.state.stateNumber == c2.state.stateNumber && c1.context.equals(c2.context);
      };

      configs.items.map(function (cfg) {
        var alts = configToAlts.get(cfg);

        if (alts === null) {
          alts = new BitSet();
          configToAlts.put(cfg, alts);
        }

        alts.add(cfg.alt);
      });
      return configToAlts.getValues();
    }; //
    // Get a map from state to alt subset from a configuration set. For each
    // configuration {@code c} in {@code configs}:
    //
    // <pre>
    // map[c.{@link ATNConfig//state state}] U= c.{@link ATNConfig//alt alt}
    // </pre>
    //


    PredictionMode.getStateToAltMap = function (configs) {
      var m = new AltDict();
      configs.items.map(function (c) {
        var alts = m.get(c.state);

        if (alts === null) {
          alts = new BitSet();
          m.put(c.state, alts);
        }

        alts.add(c.alt);
      });
      return m;
    };

    PredictionMode.hasStateAssociatedWithOneAlt = function (configs) {
      var values = PredictionMode.getStateToAltMap(configs).values();

      for (var i = 0; i < values.length; i++) {
        if (values[i].length === 1) {
          return true;
        }
      }

      return false;
    };

    PredictionMode.getSingleViableAlt = function (altsets) {
      var result = null;

      for (var i = 0; i < altsets.length; i++) {
        var alts = altsets[i];
        var minAlt = alts.minValue();

        if (result === null) {
          result = minAlt;
        } else if (result !== minAlt) {
          // more than 1 viable alt
          return ATN.INVALID_ALT_NUMBER;
        }
      }

      return result;
    };

    exports.PredictionMode = PredictionMode;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/SemanticContext.js":
  /*!****************************************************!*\
    !*** ./node_modules/antlr4/atn/SemanticContext.js ***!
    \****************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_SemanticContextJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    // A tree structure used to record the semantic context in which
    //  an ATN configuration is valid.  It's either a single predicate,
    //  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
    //
    //  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
    //  {@link SemanticContext} within the scope of this outer class.</p>
    //
    var Set = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js").Set;

    var Hash = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js").Hash;

    function SemanticContext() {
      return this;
    }

    SemanticContext.prototype.hashCode = function () {
      var hash = new Hash();
      this.updateHashCode(hash);
      return hash.finish();
    }; // For context independent predicates, we evaluate them without a local
    // context (i.e., null context). That way, we can evaluate them without
    // having to create proper rule-specific context during prediction (as
    // opposed to the parser, which creates them naturally). In a practical
    // sense, this avoids a cast exception from RuleContext to myruleContext.
    //
    // <p>For context dependent predicates, we must pass in a local context so that
    // references such as $arg evaluate properly as _localctx.arg. We only
    // capture context dependent predicates in the context in which we begin
    // prediction, so we passed in the outer context here in case of context
    // dependent predicate evaluation.</p>
    //


    SemanticContext.prototype.evaluate = function (parser, outerContext) {}; //
    // Evaluate the precedence predicates for the context and reduce the result.
    //
    // @param parser The parser instance.
    // @param outerContext The current parser context object.
    // @return The simplified semantic context after precedence predicates are
    // evaluated, which will be one of the following values.
    // <ul>
    // <li>{@link //NONE}: if the predicate simplifies to {@code true} after
    // precedence predicates are evaluated.</li>
    // <li>{@code null}: if the predicate simplifies to {@code false} after
    // precedence predicates are evaluated.</li>
    // <li>{@code this}: if the semantic context is not changed as a result of
    // precedence predicate evaluation.</li>
    // <li>A non-{@code null} {@link SemanticContext}: the new simplified
    // semantic context after precedence predicates are evaluated.</li>
    // </ul>
    //


    SemanticContext.prototype.evalPrecedence = function (parser, outerContext) {
      return this;
    };

    SemanticContext.andContext = function (a, b) {
      if (a === null || a === SemanticContext.NONE) {
        return b;
      }

      if (b === null || b === SemanticContext.NONE) {
        return a;
      }

      var result = new AND(a, b);

      if (result.opnds.length === 1) {
        return result.opnds[0];
      } else {
        return result;
      }
    };

    SemanticContext.orContext = function (a, b) {
      if (a === null) {
        return b;
      }

      if (b === null) {
        return a;
      }

      if (a === SemanticContext.NONE || b === SemanticContext.NONE) {
        return SemanticContext.NONE;
      }

      var result = new OR(a, b);

      if (result.opnds.length === 1) {
        return result.opnds[0];
      } else {
        return result;
      }
    };

    function Predicate(ruleIndex, predIndex, isCtxDependent) {
      SemanticContext.call(this);
      this.ruleIndex = ruleIndex === undefined ? -1 : ruleIndex;
      this.predIndex = predIndex === undefined ? -1 : predIndex;
      this.isCtxDependent = isCtxDependent === undefined ? false : isCtxDependent; // e.g., $i ref in pred

      return this;
    }

    Predicate.prototype = Object.create(SemanticContext.prototype);
    Predicate.prototype.constructor = Predicate; //The default {@link SemanticContext}, which is semantically equivalent to
    //a predicate of the form {@code {true}?}.
    //

    SemanticContext.NONE = new Predicate();

    Predicate.prototype.evaluate = function (parser, outerContext) {
      var localctx = this.isCtxDependent ? outerContext : null;
      return parser.sempred(localctx, this.ruleIndex, this.predIndex);
    };

    Predicate.prototype.updateHashCode = function (hash) {
      hash.update(this.ruleIndex, this.predIndex, this.isCtxDependent);
    };

    Predicate.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof Predicate)) {
        return false;
      } else {
        return this.ruleIndex === other.ruleIndex && this.predIndex === other.predIndex && this.isCtxDependent === other.isCtxDependent;
      }
    };

    Predicate.prototype.toString = function () {
      return "{" + this.ruleIndex + ":" + this.predIndex + "}?";
    };

    function PrecedencePredicate(precedence) {
      SemanticContext.call(this);
      this.precedence = precedence === undefined ? 0 : precedence;
    }

    PrecedencePredicate.prototype = Object.create(SemanticContext.prototype);
    PrecedencePredicate.prototype.constructor = PrecedencePredicate;

    PrecedencePredicate.prototype.evaluate = function (parser, outerContext) {
      return parser.precpred(outerContext, this.precedence);
    };

    PrecedencePredicate.prototype.evalPrecedence = function (parser, outerContext) {
      if (parser.precpred(outerContext, this.precedence)) {
        return SemanticContext.NONE;
      } else {
        return null;
      }
    };

    PrecedencePredicate.prototype.compareTo = function (other) {
      return this.precedence - other.precedence;
    };

    PrecedencePredicate.prototype.updateHashCode = function (hash) {
      hash.update(31);
    };

    PrecedencePredicate.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof PrecedencePredicate)) {
        return false;
      } else {
        return this.precedence === other.precedence;
      }
    };

    PrecedencePredicate.prototype.toString = function () {
      return "{" + this.precedence + ">=prec}?";
    };

    PrecedencePredicate.filterPrecedencePredicates = function (set) {
      var result = [];
      set.values().map(function (context) {
        if (context instanceof PrecedencePredicate) {
          result.push(context);
        }
      });
      return result;
    }; // A semantic context which is true whenever none of the contained contexts
    // is false.
    //


    function AND(a, b) {
      SemanticContext.call(this);
      var operands = new Set();

      if (a instanceof AND) {
        a.opnds.map(function (o) {
          operands.add(o);
        });
      } else {
        operands.add(a);
      }

      if (b instanceof AND) {
        b.opnds.map(function (o) {
          operands.add(o);
        });
      } else {
        operands.add(b);
      }

      var precedencePredicates = PrecedencePredicate.filterPrecedencePredicates(operands);

      if (precedencePredicates.length > 0) {
        // interested in the transition with the lowest precedence
        var reduced = null;
        precedencePredicates.map(function (p) {
          if (reduced === null || p.precedence < reduced.precedence) {
            reduced = p;
          }
        });
        operands.add(reduced);
      }

      this.opnds = operands.values();
      return this;
    }

    AND.prototype = Object.create(SemanticContext.prototype);
    AND.prototype.constructor = AND;

    AND.prototype.equals = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof AND)) {
        return false;
      } else {
        return this.opnds === other.opnds;
      }
    };

    AND.prototype.updateHashCode = function (hash) {
      hash.update(this.opnds, "AND");
    }; //
    // {@inheritDoc}
    //
    // <p>
    // The evaluation of predicates by this context is short-circuiting, but
    // unordered.</p>
    //


    AND.prototype.evaluate = function (parser, outerContext) {
      for (var i = 0; i < this.opnds.length; i++) {
        if (!this.opnds[i].evaluate(parser, outerContext)) {
          return false;
        }
      }

      return true;
    };

    AND.prototype.evalPrecedence = function (parser, outerContext) {
      var differs = false;
      var operands = [];

      for (var i = 0; i < this.opnds.length; i++) {
        var context = this.opnds[i];
        var evaluated = context.evalPrecedence(parser, outerContext);
        differs |= evaluated !== context;

        if (evaluated === null) {
          // The AND context is false if any element is false
          return null;
        } else if (evaluated !== SemanticContext.NONE) {
          // Reduce the result by skipping true elements
          operands.push(evaluated);
        }
      }

      if (!differs) {
        return this;
      }

      if (operands.length === 0) {
        // all elements were true, so the AND context is true
        return SemanticContext.NONE;
      }

      var result = null;
      operands.map(function (o) {
        result = result === null ? o : SemanticContext.andContext(result, o);
      });
      return result;
    };

    AND.prototype.toString = function () {
      var s = "";
      this.opnds.map(function (o) {
        s += "&& " + o.toString();
      });
      return s.length > 3 ? s.slice(3) : s;
    }; //
    // A semantic context which is true whenever at least one of the contained
    // contexts is true.
    //


    function OR(a, b) {
      SemanticContext.call(this);
      var operands = new Set();

      if (a instanceof OR) {
        a.opnds.map(function (o) {
          operands.add(o);
        });
      } else {
        operands.add(a);
      }

      if (b instanceof OR) {
        b.opnds.map(function (o) {
          operands.add(o);
        });
      } else {
        operands.add(b);
      }

      var precedencePredicates = PrecedencePredicate.filterPrecedencePredicates(operands);

      if (precedencePredicates.length > 0) {
        // interested in the transition with the highest precedence
        var s = precedencePredicates.sort(function (a, b) {
          return a.compareTo(b);
        });
        var reduced = s[s.length - 1];
        operands.add(reduced);
      }

      this.opnds = operands.values();
      return this;
    }

    OR.prototype = Object.create(SemanticContext.prototype);
    OR.prototype.constructor = OR;

    OR.prototype.constructor = function (other) {
      if (this === other) {
        return true;
      } else if (!(other instanceof OR)) {
        return false;
      } else {
        return this.opnds === other.opnds;
      }
    };

    OR.prototype.updateHashCode = function (hash) {
      hash.update(this.opnds, "OR");
    }; // <p>
    // The evaluation of predicates by this context is short-circuiting, but
    // unordered.</p>
    //


    OR.prototype.evaluate = function (parser, outerContext) {
      for (var i = 0; i < this.opnds.length; i++) {
        if (this.opnds[i].evaluate(parser, outerContext)) {
          return true;
        }
      }

      return false;
    };

    OR.prototype.evalPrecedence = function (parser, outerContext) {
      var differs = false;
      var operands = [];

      for (var i = 0; i < this.opnds.length; i++) {
        var context = this.opnds[i];
        var evaluated = context.evalPrecedence(parser, outerContext);
        differs |= evaluated !== context;

        if (evaluated === SemanticContext.NONE) {
          // The OR context is true if any element is true
          return SemanticContext.NONE;
        } else if (evaluated !== null) {
          // Reduce the result by skipping false elements
          operands.push(evaluated);
        }
      }

      if (!differs) {
        return this;
      }

      if (operands.length === 0) {
        // all elements were false, so the OR context is false
        return null;
      }

      var result = null;
      operands.map(function (o) {
        return result === null ? o : SemanticContext.orContext(result, o);
      });
      return result;
    };

    OR.prototype.toString = function () {
      var s = "";
      this.opnds.map(function (o) {
        s += "|| " + o.toString();
      });
      return s.length > 3 ? s.slice(3) : s;
    };

    exports.SemanticContext = SemanticContext;
    exports.PrecedencePredicate = PrecedencePredicate;
    exports.Predicate = Predicate;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/Transition.js":
  /*!***********************************************!*\
    !*** ./node_modules/antlr4/atn/Transition.js ***!
    \***********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_TransitionJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    //  An ATN transition between any two ATN states.  Subclasses define
    //  atom, set, epsilon, action, predicate, rule transitions.
    //
    //  <p>This is a one way link.  It emanates from a state (usually via a list of
    //  transitions) and has a target state.</p>
    //
    //  <p>Since we never have to change the ATN transitions once we construct it,
    //  we can fix these transitions as specific classes. The DFA transitions
    //  on the other hand need to update the labels as it adds transitions to
    //  the states. We'll use the term Edge for the DFA to distinguish them from
    //  ATN transitions.</p>
    var Token = __webpack_require__(
    /*! ./../Token */
    "./node_modules/antlr4/Token.js").Token;

    var Interval = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval;

    var IntervalSet = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").IntervalSet;

    var Predicate = __webpack_require__(
    /*! ./SemanticContext */
    "./node_modules/antlr4/atn/SemanticContext.js").Predicate;

    var PrecedencePredicate = __webpack_require__(
    /*! ./SemanticContext */
    "./node_modules/antlr4/atn/SemanticContext.js").PrecedencePredicate;

    function Transition(target) {
      // The target of this transition.
      if (target === undefined || target === null) {
        throw "target cannot be null.";
      }

      this.target = target; // Are we epsilon, action, sempred?

      this.isEpsilon = false;
      this.label = null;
      return this;
    } // constants for serialization


    Transition.EPSILON = 1;
    Transition.RANGE = 2;
    Transition.RULE = 3;
    Transition.PREDICATE = 4; // e.g., {isType(input.LT(1))}?

    Transition.ATOM = 5;
    Transition.ACTION = 6;
    Transition.SET = 7; // ~(A|B) or ~atom, wildcard, which convert to next 2

    Transition.NOT_SET = 8;
    Transition.WILDCARD = 9;
    Transition.PRECEDENCE = 10;
    Transition.serializationNames = ["INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION", "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"];
    Transition.serializationTypes = {
      EpsilonTransition: Transition.EPSILON,
      RangeTransition: Transition.RANGE,
      RuleTransition: Transition.RULE,
      PredicateTransition: Transition.PREDICATE,
      AtomTransition: Transition.ATOM,
      ActionTransition: Transition.ACTION,
      SetTransition: Transition.SET,
      NotSetTransition: Transition.NOT_SET,
      WildcardTransition: Transition.WILDCARD,
      PrecedencePredicateTransition: Transition.PRECEDENCE
    }; // TODO: make all transitions sets? no, should remove set edges

    function AtomTransition(target, label) {
      Transition.call(this, target);
      this.label_ = label; // The token type or character value; or, signifies special label.

      this.label = this.makeLabel();
      this.serializationType = Transition.ATOM;
      return this;
    }

    AtomTransition.prototype = Object.create(Transition.prototype);
    AtomTransition.prototype.constructor = AtomTransition;

    AtomTransition.prototype.makeLabel = function () {
      var s = new IntervalSet();
      s.addOne(this.label_);
      return s;
    };

    AtomTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return this.label_ === symbol;
    };

    AtomTransition.prototype.toString = function () {
      return this.label_;
    };

    function RuleTransition(ruleStart, ruleIndex, precedence, followState) {
      Transition.call(this, ruleStart);
      this.ruleIndex = ruleIndex; // ptr to the rule definition object for this rule ref

      this.precedence = precedence;
      this.followState = followState; // what node to begin computations following ref to rule

      this.serializationType = Transition.RULE;
      this.isEpsilon = true;
      return this;
    }

    RuleTransition.prototype = Object.create(Transition.prototype);
    RuleTransition.prototype.constructor = RuleTransition;

    RuleTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return false;
    };

    function EpsilonTransition(target, outermostPrecedenceReturn) {
      Transition.call(this, target);
      this.serializationType = Transition.EPSILON;
      this.isEpsilon = true;
      this.outermostPrecedenceReturn = outermostPrecedenceReturn;
      return this;
    }

    EpsilonTransition.prototype = Object.create(Transition.prototype);
    EpsilonTransition.prototype.constructor = EpsilonTransition;

    EpsilonTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return false;
    };

    EpsilonTransition.prototype.toString = function () {
      return "epsilon";
    };

    function RangeTransition(target, start, stop) {
      Transition.call(this, target);
      this.serializationType = Transition.RANGE;
      this.start = start;
      this.stop = stop;
      this.label = this.makeLabel();
      return this;
    }

    RangeTransition.prototype = Object.create(Transition.prototype);
    RangeTransition.prototype.constructor = RangeTransition;

    RangeTransition.prototype.makeLabel = function () {
      var s = new IntervalSet();
      s.addRange(this.start, this.stop);
      return s;
    };

    RangeTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return symbol >= this.start && symbol <= this.stop;
    };

    RangeTransition.prototype.toString = function () {
      return "'" + String.fromCharCode(this.start) + "'..'" + String.fromCharCode(this.stop) + "'";
    };

    function AbstractPredicateTransition(target) {
      Transition.call(this, target);
      return this;
    }

    AbstractPredicateTransition.prototype = Object.create(Transition.prototype);
    AbstractPredicateTransition.prototype.constructor = AbstractPredicateTransition;

    function PredicateTransition(target, ruleIndex, predIndex, isCtxDependent) {
      AbstractPredicateTransition.call(this, target);
      this.serializationType = Transition.PREDICATE;
      this.ruleIndex = ruleIndex;
      this.predIndex = predIndex;
      this.isCtxDependent = isCtxDependent; // e.g., $i ref in pred

      this.isEpsilon = true;
      return this;
    }

    PredicateTransition.prototype = Object.create(AbstractPredicateTransition.prototype);
    PredicateTransition.prototype.constructor = PredicateTransition;

    PredicateTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return false;
    };

    PredicateTransition.prototype.getPredicate = function () {
      return new Predicate(this.ruleIndex, this.predIndex, this.isCtxDependent);
    };

    PredicateTransition.prototype.toString = function () {
      return "pred_" + this.ruleIndex + ":" + this.predIndex;
    };

    function ActionTransition(target, ruleIndex, actionIndex, isCtxDependent) {
      Transition.call(this, target);
      this.serializationType = Transition.ACTION;
      this.ruleIndex = ruleIndex;
      this.actionIndex = actionIndex === undefined ? -1 : actionIndex;
      this.isCtxDependent = isCtxDependent === undefined ? false : isCtxDependent; // e.g., $i ref in pred

      this.isEpsilon = true;
      return this;
    }

    ActionTransition.prototype = Object.create(Transition.prototype);
    ActionTransition.prototype.constructor = ActionTransition;

    ActionTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return false;
    };

    ActionTransition.prototype.toString = function () {
      return "action_" + this.ruleIndex + ":" + this.actionIndex;
    }; // A transition containing a set of values.


    function SetTransition(target, set) {
      Transition.call(this, target);
      this.serializationType = Transition.SET;

      if (set !== undefined && set !== null) {
        this.label = set;
      } else {
        this.label = new IntervalSet();
        this.label.addOne(Token.INVALID_TYPE);
      }

      return this;
    }

    SetTransition.prototype = Object.create(Transition.prototype);
    SetTransition.prototype.constructor = SetTransition;

    SetTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return this.label.contains(symbol);
    };

    SetTransition.prototype.toString = function () {
      return this.label.toString();
    };

    function NotSetTransition(target, set) {
      SetTransition.call(this, target, set);
      this.serializationType = Transition.NOT_SET;
      return this;
    }

    NotSetTransition.prototype = Object.create(SetTransition.prototype);
    NotSetTransition.prototype.constructor = NotSetTransition;

    NotSetTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return symbol >= minVocabSymbol && symbol <= maxVocabSymbol && !SetTransition.prototype.matches.call(this, symbol, minVocabSymbol, maxVocabSymbol);
    };

    NotSetTransition.prototype.toString = function () {
      return '~' + SetTransition.prototype.toString.call(this);
    };

    function WildcardTransition(target) {
      Transition.call(this, target);
      this.serializationType = Transition.WILDCARD;
      return this;
    }

    WildcardTransition.prototype = Object.create(Transition.prototype);
    WildcardTransition.prototype.constructor = WildcardTransition;

    WildcardTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return symbol >= minVocabSymbol && symbol <= maxVocabSymbol;
    };

    WildcardTransition.prototype.toString = function () {
      return ".";
    };

    function PrecedencePredicateTransition(target, precedence) {
      AbstractPredicateTransition.call(this, target);
      this.serializationType = Transition.PRECEDENCE;
      this.precedence = precedence;
      this.isEpsilon = true;
      return this;
    }

    PrecedencePredicateTransition.prototype = Object.create(AbstractPredicateTransition.prototype);
    PrecedencePredicateTransition.prototype.constructor = PrecedencePredicateTransition;

    PrecedencePredicateTransition.prototype.matches = function (symbol, minVocabSymbol, maxVocabSymbol) {
      return false;
    };

    PrecedencePredicateTransition.prototype.getPredicate = function () {
      return new PrecedencePredicate(this.precedence);
    };

    PrecedencePredicateTransition.prototype.toString = function () {
      return this.precedence + " >= _p";
    };

    exports.Transition = Transition;
    exports.AtomTransition = AtomTransition;
    exports.SetTransition = SetTransition;
    exports.NotSetTransition = NotSetTransition;
    exports.RuleTransition = RuleTransition;
    exports.ActionTransition = ActionTransition;
    exports.EpsilonTransition = EpsilonTransition;
    exports.RangeTransition = RangeTransition;
    exports.WildcardTransition = WildcardTransition;
    exports.PredicateTransition = PredicateTransition;
    exports.PrecedencePredicateTransition = PrecedencePredicateTransition;
    exports.AbstractPredicateTransition = AbstractPredicateTransition;
    /***/
  },

  /***/
  "./node_modules/antlr4/atn/index.js":
  /*!******************************************!*\
    !*** ./node_modules/antlr4/atn/index.js ***!
    \******************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_atn_indexJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    exports.ATN = __webpack_require__(
    /*! ./ATN */
    "./node_modules/antlr4/atn/ATN.js").ATN;
    exports.ATNDeserializer = __webpack_require__(
    /*! ./ATNDeserializer */
    "./node_modules/antlr4/atn/ATNDeserializer.js").ATNDeserializer;
    exports.LexerATNSimulator = __webpack_require__(
    /*! ./LexerATNSimulator */
    "./node_modules/antlr4/atn/LexerATNSimulator.js").LexerATNSimulator;
    exports.ParserATNSimulator = __webpack_require__(
    /*! ./ParserATNSimulator */
    "./node_modules/antlr4/atn/ParserATNSimulator.js").ParserATNSimulator;
    exports.PredictionMode = __webpack_require__(
    /*! ./PredictionMode */
    "./node_modules/antlr4/atn/PredictionMode.js").PredictionMode;
    /***/
  },

  /***/
  "./node_modules/antlr4/dfa/DFA.js":
  /*!****************************************!*\
    !*** ./node_modules/antlr4/dfa/DFA.js ***!
    \****************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_dfa_DFAJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    var Set = __webpack_require__(
    /*! ../Utils */
    "./node_modules/antlr4/Utils.js").Set;

    var DFAState = __webpack_require__(
    /*! ./DFAState */
    "./node_modules/antlr4/dfa/DFAState.js").DFAState;

    var StarLoopEntryState = __webpack_require__(
    /*! ../atn/ATNState */
    "./node_modules/antlr4/atn/ATNState.js").StarLoopEntryState;

    var ATNConfigSet = __webpack_require__(
    /*! ./../atn/ATNConfigSet */
    "./node_modules/antlr4/atn/ATNConfigSet.js").ATNConfigSet;

    var DFASerializer = __webpack_require__(
    /*! ./DFASerializer */
    "./node_modules/antlr4/dfa/DFASerializer.js").DFASerializer;

    var LexerDFASerializer = __webpack_require__(
    /*! ./DFASerializer */
    "./node_modules/antlr4/dfa/DFASerializer.js").LexerDFASerializer;

    function DFA(atnStartState, decision) {
      if (decision === undefined) {
        decision = 0;
      } // From which ATN state did we create this DFA?


      this.atnStartState = atnStartState;
      this.decision = decision; // A set of all DFA states. Use {@link Map} so we can get old state back
      // ({@link Set} only allows you to see if it's there).

      this._states = new Set();
      this.s0 = null; // {@code true} if this DFA is for a precedence decision; otherwise,
      // {@code false}. This is the backing field for {@link //isPrecedenceDfa},
      // {@link //setPrecedenceDfa}.

      this.precedenceDfa = false;

      if (atnStartState instanceof StarLoopEntryState) {
        if (atnStartState.isPrecedenceDecision) {
          this.precedenceDfa = true;
          var precedenceState = new DFAState(null, new ATNConfigSet());
          precedenceState.edges = [];
          precedenceState.isAcceptState = false;
          precedenceState.requiresFullContext = false;
          this.s0 = precedenceState;
        }
      }

      return this;
    } // Get the start state for a specific precedence value.
    //
    // @param precedence The current precedence.
    // @return The start state corresponding to the specified precedence, or
    // {@code null} if no start state exists for the specified precedence.
    //
    // @throws IllegalStateException if this is not a precedence DFA.
    // @see //isPrecedenceDfa()


    DFA.prototype.getPrecedenceStartState = function (precedence) {
      if (!this.precedenceDfa) {
        throw "Only precedence DFAs may contain a precedence start state.";
      } // s0.edges is never null for a precedence DFA


      if (precedence < 0 || precedence >= this.s0.edges.length) {
        return null;
      }

      return this.s0.edges[precedence] || null;
    }; // Set the start state for a specific precedence value.
    //
    // @param precedence The current precedence.
    // @param startState The start state corresponding to the specified
    // precedence.
    //
    // @throws IllegalStateException if this is not a precedence DFA.
    // @see //isPrecedenceDfa()
    //


    DFA.prototype.setPrecedenceStartState = function (precedence, startState) {
      if (!this.precedenceDfa) {
        throw "Only precedence DFAs may contain a precedence start state.";
      }

      if (precedence < 0) {
        return;
      } // synchronization on s0 here is ok. when the DFA is turned into a
      // precedence DFA, s0 will be initialized once and not updated again
      // s0.edges is never null for a precedence DFA


      this.s0.edges[precedence] = startState;
    }; //
    // Sets whether this is a precedence DFA. If the specified value differs
    // from the current DFA configuration, the following actions are taken;
    // otherwise no changes are made to the current DFA.
    //
    // <ul>
    // <li>The {@link //states} map is cleared</li>
    // <li>If {@code precedenceDfa} is {@code false}, the initial state
    // {@link //s0} is set to {@code null}; otherwise, it is initialized to a new
    // {@link DFAState} with an empty outgoing {@link DFAState//edges} array to
    // store the start states for individual precedence values.</li>
    // <li>The {@link //precedenceDfa} field is updated</li>
    // </ul>
    //
    // @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,
    // {@code false}


    DFA.prototype.setPrecedenceDfa = function (precedenceDfa) {
      if (this.precedenceDfa !== precedenceDfa) {
        this._states = new DFAStatesSet();

        if (precedenceDfa) {
          var precedenceState = new DFAState(null, new ATNConfigSet());
          precedenceState.edges = [];
          precedenceState.isAcceptState = false;
          precedenceState.requiresFullContext = false;
          this.s0 = precedenceState;
        } else {
          this.s0 = null;
        }

        this.precedenceDfa = precedenceDfa;
      }
    };

    Object.defineProperty(DFA.prototype, "states", {
      get: function get() {
        return this._states;
      }
    }); // Return a list of all states in this DFA, ordered by state number.

    DFA.prototype.sortedStates = function () {
      var list = this._states.values();

      return list.sort(function (a, b) {
        return a.stateNumber - b.stateNumber;
      });
    };

    DFA.prototype.toString = function (literalNames, symbolicNames) {
      literalNames = literalNames || null;
      symbolicNames = symbolicNames || null;

      if (this.s0 === null) {
        return "";
      }

      var serializer = new DFASerializer(this, literalNames, symbolicNames);
      return serializer.toString();
    };

    DFA.prototype.toLexerString = function () {
      if (this.s0 === null) {
        return "";
      }

      var serializer = new LexerDFASerializer(this);
      return serializer.toString();
    };

    exports.DFA = DFA;
    /***/
  },

  /***/
  "./node_modules/antlr4/dfa/DFASerializer.js":
  /*!**************************************************!*\
    !*** ./node_modules/antlr4/dfa/DFASerializer.js ***!
    \**************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_dfa_DFASerializerJs(module, exports) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    // A DFA walker that knows how to dump them to serialized strings.#/
    function DFASerializer(dfa, literalNames, symbolicNames) {
      this.dfa = dfa;
      this.literalNames = literalNames || [];
      this.symbolicNames = symbolicNames || [];
      return this;
    }

    DFASerializer.prototype.toString = function () {
      if (this.dfa.s0 === null) {
        return null;
      }

      var buf = "";
      var states = this.dfa.sortedStates();

      for (var i = 0; i < states.length; i++) {
        var s = states[i];

        if (s.edges !== null) {
          var n = s.edges.length;

          for (var j = 0; j < n; j++) {
            var t = s.edges[j] || null;

            if (t !== null && t.stateNumber !== 0x7FFFFFFF) {
              buf = buf.concat(this.getStateString(s));
              buf = buf.concat("-");
              buf = buf.concat(this.getEdgeLabel(j));
              buf = buf.concat("->");
              buf = buf.concat(this.getStateString(t));
              buf = buf.concat('\n');
            }
          }
        }
      }

      return buf.length === 0 ? null : buf;
    };

    DFASerializer.prototype.getEdgeLabel = function (i) {
      if (i === 0) {
        return "EOF";
      } else if (this.literalNames !== null || this.symbolicNames !== null) {
        return this.literalNames[i - 1] || this.symbolicNames[i - 1];
      } else {
        return String.fromCharCode(i - 1);
      }
    };

    DFASerializer.prototype.getStateString = function (s) {
      var baseStateStr = (s.isAcceptState ? ":" : "") + "s" + s.stateNumber + (s.requiresFullContext ? "^" : "");

      if (s.isAcceptState) {
        if (s.predicates !== null) {
          return baseStateStr + "=>" + s.predicates.toString();
        } else {
          return baseStateStr + "=>" + s.prediction.toString();
        }
      } else {
        return baseStateStr;
      }
    };

    function LexerDFASerializer(dfa) {
      DFASerializer.call(this, dfa, null);
      return this;
    }

    LexerDFASerializer.prototype = Object.create(DFASerializer.prototype);
    LexerDFASerializer.prototype.constructor = LexerDFASerializer;

    LexerDFASerializer.prototype.getEdgeLabel = function (i) {
      return "'" + String.fromCharCode(i) + "'";
    };

    exports.DFASerializer = DFASerializer;
    exports.LexerDFASerializer = LexerDFASerializer;
    /***/
  },

  /***/
  "./node_modules/antlr4/dfa/DFAState.js":
  /*!*********************************************!*\
    !*** ./node_modules/antlr4/dfa/DFAState.js ***!
    \*********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_dfa_DFAStateJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    var ATNConfigSet = __webpack_require__(
    /*! ./../atn/ATNConfigSet */
    "./node_modules/antlr4/atn/ATNConfigSet.js").ATNConfigSet;

    var Utils = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js");

    var Hash = Utils.Hash;
    var Set = Utils.Set; // Map a predicate to a predicted alternative.///

    function PredPrediction(pred, alt) {
      this.alt = alt;
      this.pred = pred;
      return this;
    }

    PredPrediction.prototype.toString = function () {
      return "(" + this.pred + ", " + this.alt + ")";
    }; // A DFA state represents a set of possible ATN configurations.
    // As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
    // to keep track of all possible states the ATN can be in after
    // reading each input symbol. That is to say, after reading
    // input a1a2..an, the DFA is in a state that represents the
    // subset T of the states of the ATN that are reachable from the
    // ATN's start state along some path labeled a1a2..an."
    // In conventional NFA&rarr;DFA conversion, therefore, the subset T
    // would be a bitset representing the set of states the
    // ATN could be in. We need to track the alt predicted by each
    // state as well, however. More importantly, we need to maintain
    // a stack of states, tracking the closure operations as they
    // jump from rule to rule, emulating rule invocations (method calls).
    // I have to add a stack to simulate the proper lookahead sequences for
    // the underlying LL grammar from which the ATN was derived.
    //
    // <p>I use a set of ATNConfig objects not simple states. An ATNConfig
    // is both a state (ala normal conversion) and a RuleContext describing
    // the chain of rules (if any) followed to arrive at that state.</p>
    //
    // <p>A DFA state may have multiple references to a particular state,
    // but with different ATN contexts (with same or different alts)
    // meaning that state was reached via a different set of rule invocations.</p>
    // /


    function DFAState(stateNumber, configs) {
      if (stateNumber === null) {
        stateNumber = -1;
      }

      if (configs === null) {
        configs = new ATNConfigSet();
      }

      this.stateNumber = stateNumber;
      this.configs = configs; // {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)
      // {@link Token//EOF} maps to {@code edges[0]}.

      this.edges = null;
      this.isAcceptState = false; // if accept state, what ttype do we match or alt do we predict?
      // This is set to {@link ATN//INVALID_ALT_NUMBER} when {@link
      // //predicates}{@code !=null} or
      // {@link //requiresFullContext}.

      this.prediction = 0;
      this.lexerActionExecutor = null; // Indicates that this state was created during SLL prediction that
      // discovered a conflict between the configurations in the state. Future
      // {@link ParserATNSimulator//execATN} invocations immediately jumped doing
      // full context prediction if this field is true.

      this.requiresFullContext = false; // During SLL parsing, this is a list of predicates associated with the
      // ATN configurations of the DFA state. When we have predicates,
      // {@link //requiresFullContext} is {@code false} since full context
      // prediction evaluates predicates
      // on-the-fly. If this is not null, then {@link //prediction} is
      // {@link ATN//INVALID_ALT_NUMBER}.
      //
      // <p>We only use these for non-{@link //requiresFullContext} but
      // conflicting states. That
      // means we know from the context (it's $ or we don't dip into outer
      // context) that it's an ambiguity not a conflict.</p>
      //
      // <p>This list is computed by {@link
      // ParserATNSimulator//predicateDFAState}.</p>

      this.predicates = null;
      return this;
    } // Get the set of all alts mentioned by all ATN configurations in this
    // DFA state.


    DFAState.prototype.getAltSet = function () {
      var alts = new Set();

      if (this.configs !== null) {
        for (var i = 0; i < this.configs.length; i++) {
          var c = this.configs[i];
          alts.add(c.alt);
        }
      }

      if (alts.length === 0) {
        return null;
      } else {
        return alts;
      }
    }; // Two {@link DFAState} instances are equal if their ATN configuration sets
    // are the same. This method is used to see if a state already exists.
    //
    // <p>Because the number of alternatives and number of ATN configurations are
    // finite, there is a finite number of DFA states that can be processed.
    // This is necessary to show that the algorithm terminates.</p>
    //
    // <p>Cannot test the DFA state numbers here because in
    // {@link ParserATNSimulator//addDFAState} we need to know if any other state
    // exists that has this exact set of ATN configurations. The
    // {@link //stateNumber} is irrelevant.</p>


    DFAState.prototype.equals = function (other) {
      // compare set of ATN configurations in this set with other
      return this === other || other instanceof DFAState && this.configs.equals(other.configs);
    };

    DFAState.prototype.toString = function () {
      var s = "" + this.stateNumber + ":" + this.configs;

      if (this.isAcceptState) {
        s = s + "=>";
        if (this.predicates !== null) s = s + this.predicates;else s = s + this.prediction;
      }

      return s;
    };

    DFAState.prototype.hashCode = function () {
      var hash = new Hash();
      hash.update(this.configs);

      if (this.isAcceptState) {
        if (this.predicates !== null) hash.update(this.predicates);else hash.update(this.prediction);
      }

      return hash.finish();
    };

    exports.DFAState = DFAState;
    exports.PredPrediction = PredPrediction;
    /***/
  },

  /***/
  "./node_modules/antlr4/dfa/index.js":
  /*!******************************************!*\
    !*** ./node_modules/antlr4/dfa/index.js ***!
    \******************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_dfa_indexJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    exports.DFA = __webpack_require__(
    /*! ./DFA */
    "./node_modules/antlr4/dfa/DFA.js").DFA;
    exports.DFASerializer = __webpack_require__(
    /*! ./DFASerializer */
    "./node_modules/antlr4/dfa/DFASerializer.js").DFASerializer;
    exports.LexerDFASerializer = __webpack_require__(
    /*! ./DFASerializer */
    "./node_modules/antlr4/dfa/DFASerializer.js").LexerDFASerializer;
    exports.PredPrediction = __webpack_require__(
    /*! ./DFAState */
    "./node_modules/antlr4/dfa/DFAState.js").PredPrediction;
    /***/
  },

  /***/
  "./node_modules/antlr4/error/DiagnosticErrorListener.js":
  /*!**************************************************************!*\
    !*** ./node_modules/antlr4/error/DiagnosticErrorListener.js ***!
    \**************************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_error_DiagnosticErrorListenerJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    //
    // This implementation of {@link ANTLRErrorListener} can be used to identify
    // certain potential correctness and performance problems in grammars. "Reports"
    // are made by calling {@link Parser//notifyErrorListeners} with the appropriate
    // message.
    //
    // <ul>
    // <li><b>Ambiguities</b>: These are cases where more than one path through the
    // grammar can match the input.</li>
    // <li><b>Weak context sensitivity</b>: These are cases where full-context
    // prediction resolved an SLL conflict to a unique alternative which equaled the
    // minimum alternative of the SLL conflict.</li>
    // <li><b>Strong (forced) context sensitivity</b>: These are cases where the
    // full-context prediction resolved an SLL conflict to a unique alternative,
    // <em>and</em> the minimum alternative of the SLL conflict was found to not be
    // a truly viable alternative. Two-stage parsing cannot be used for inputs where
    // this situation occurs.</li>
    // </ul>
    var BitSet = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js").BitSet;

    var ErrorListener = __webpack_require__(
    /*! ./ErrorListener */
    "./node_modules/antlr4/error/ErrorListener.js").ErrorListener;

    var Interval = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval;

    function DiagnosticErrorListener(exactOnly) {
      ErrorListener.call(this);
      exactOnly = exactOnly || true; // whether all ambiguities or only exact ambiguities are reported.

      this.exactOnly = exactOnly;
      return this;
    }

    DiagnosticErrorListener.prototype = Object.create(ErrorListener.prototype);
    DiagnosticErrorListener.prototype.constructor = DiagnosticErrorListener;

    DiagnosticErrorListener.prototype.reportAmbiguity = function (recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
      if (this.exactOnly && !exact) {
        return;
      }

      var msg = "reportAmbiguity d=" + this.getDecisionDescription(recognizer, dfa) + ": ambigAlts=" + this.getConflictingAlts(ambigAlts, configs) + ", input='" + recognizer.getTokenStream().getText(new Interval(startIndex, stopIndex)) + "'";
      recognizer.notifyErrorListeners(msg);
    };

    DiagnosticErrorListener.prototype.reportAttemptingFullContext = function (recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
      var msg = "reportAttemptingFullContext d=" + this.getDecisionDescription(recognizer, dfa) + ", input='" + recognizer.getTokenStream().getText(new Interval(startIndex, stopIndex)) + "'";
      recognizer.notifyErrorListeners(msg);
    };

    DiagnosticErrorListener.prototype.reportContextSensitivity = function (recognizer, dfa, startIndex, stopIndex, prediction, configs) {
      var msg = "reportContextSensitivity d=" + this.getDecisionDescription(recognizer, dfa) + ", input='" + recognizer.getTokenStream().getText(new Interval(startIndex, stopIndex)) + "'";
      recognizer.notifyErrorListeners(msg);
    };

    DiagnosticErrorListener.prototype.getDecisionDescription = function (recognizer, dfa) {
      var decision = dfa.decision;
      var ruleIndex = dfa.atnStartState.ruleIndex;
      var ruleNames = recognizer.ruleNames;

      if (ruleIndex < 0 || ruleIndex >= ruleNames.length) {
        return "" + decision;
      }

      var ruleName = ruleNames[ruleIndex] || null;

      if (ruleName === null || ruleName.length === 0) {
        return "" + decision;
      }

      return "" + decision + " (" + ruleName + ")";
    }; //
    // Computes the set of conflicting or ambiguous alternatives from a
    // configuration set, if that information was not already provided by the
    // parser.
    //
    // @param reportedAlts The set of conflicting or ambiguous alternatives, as
    // reported by the parser.
    // @param configs The conflicting or ambiguous configuration set.
    // @return Returns {@code reportedAlts} if it is not {@code null}, otherwise
    // returns the set of alternatives represented in {@code configs}.
    //


    DiagnosticErrorListener.prototype.getConflictingAlts = function (reportedAlts, configs) {
      if (reportedAlts !== null) {
        return reportedAlts;
      }

      var result = new BitSet();

      for (var i = 0; i < configs.items.length; i++) {
        result.add(configs.items[i].alt);
      }

      return "{" + result.values().join(", ") + "}";
    };

    exports.DiagnosticErrorListener = DiagnosticErrorListener;
    /***/
  },

  /***/
  "./node_modules/antlr4/error/ErrorListener.js":
  /*!****************************************************!*\
    !*** ./node_modules/antlr4/error/ErrorListener.js ***!
    \****************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_error_ErrorListenerJs(module, exports) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    // Provides an empty default implementation of {@link ANTLRErrorListener}. The
    // default implementation of each method does nothing, but can be overridden as
    // necessary.
    function ErrorListener() {
      return this;
    }

    ErrorListener.prototype.syntaxError = function (recognizer, offendingSymbol, line, column, msg, e) {};

    ErrorListener.prototype.reportAmbiguity = function (recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {};

    ErrorListener.prototype.reportAttemptingFullContext = function (recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {};

    ErrorListener.prototype.reportContextSensitivity = function (recognizer, dfa, startIndex, stopIndex, prediction, configs) {};

    function ConsoleErrorListener() {
      ErrorListener.call(this);
      return this;
    }

    ConsoleErrorListener.prototype = Object.create(ErrorListener.prototype);
    ConsoleErrorListener.prototype.constructor = ConsoleErrorListener; //
    // Provides a default instance of {@link ConsoleErrorListener}.
    //

    ConsoleErrorListener.INSTANCE = new ConsoleErrorListener(); //
    // {@inheritDoc}
    //
    // <p>
    // This implementation prints messages to {@link System//err} containing the
    // values of {@code line}, {@code charPositionInLine}, and {@code msg} using
    // the following format.</p>
    //
    // <pre>
    // line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
    // </pre>
    //

    ConsoleErrorListener.prototype.syntaxError = function (recognizer, offendingSymbol, line, column, msg, e) {
      console.error("line " + line + ":" + column + " " + msg);
    };

    function ProxyErrorListener(delegates) {
      ErrorListener.call(this);

      if (delegates === null) {
        throw "delegates";
      }

      this.delegates = delegates;
      return this;
    }

    ProxyErrorListener.prototype = Object.create(ErrorListener.prototype);
    ProxyErrorListener.prototype.constructor = ProxyErrorListener;

    ProxyErrorListener.prototype.syntaxError = function (recognizer, offendingSymbol, line, column, msg, e) {
      this.delegates.map(function (d) {
        d.syntaxError(recognizer, offendingSymbol, line, column, msg, e);
      });
    };

    ProxyErrorListener.prototype.reportAmbiguity = function (recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
      this.delegates.map(function (d) {
        d.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
      });
    };

    ProxyErrorListener.prototype.reportAttemptingFullContext = function (recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
      this.delegates.map(function (d) {
        d.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs);
      });
    };

    ProxyErrorListener.prototype.reportContextSensitivity = function (recognizer, dfa, startIndex, stopIndex, prediction, configs) {
      this.delegates.map(function (d) {
        d.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs);
      });
    };

    exports.ErrorListener = ErrorListener;
    exports.ConsoleErrorListener = ConsoleErrorListener;
    exports.ProxyErrorListener = ProxyErrorListener;
    /***/
  },

  /***/
  "./node_modules/antlr4/error/ErrorStrategy.js":
  /*!****************************************************!*\
    !*** ./node_modules/antlr4/error/ErrorStrategy.js ***!
    \****************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_error_ErrorStrategyJs(module, exports, __webpack_require__) {
    //

    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    //
    var Token = __webpack_require__(
    /*! ./../Token */
    "./node_modules/antlr4/Token.js").Token;

    var Errors = __webpack_require__(
    /*! ./Errors */
    "./node_modules/antlr4/error/Errors.js");

    var NoViableAltException = Errors.NoViableAltException;
    var InputMismatchException = Errors.InputMismatchException;
    var FailedPredicateException = Errors.FailedPredicateException;
    var ParseCancellationException = Errors.ParseCancellationException;

    var ATNState = __webpack_require__(
    /*! ./../atn/ATNState */
    "./node_modules/antlr4/atn/ATNState.js").ATNState;

    var Interval = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval;

    var IntervalSet = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").IntervalSet;

    function ErrorStrategy() {}

    ErrorStrategy.prototype.reset = function (recognizer) {};

    ErrorStrategy.prototype.recoverInline = function (recognizer) {};

    ErrorStrategy.prototype.recover = function (recognizer, e) {};

    ErrorStrategy.prototype.sync = function (recognizer) {};

    ErrorStrategy.prototype.inErrorRecoveryMode = function (recognizer) {};

    ErrorStrategy.prototype.reportError = function (recognizer) {}; // This is the default implementation of {@link ANTLRErrorStrategy} used for
    // error reporting and recovery in ANTLR parsers.
    //


    function DefaultErrorStrategy() {
      ErrorStrategy.call(this); // Indicates whether the error strategy is currently "recovering from an
      // error". This is used to suppress reporting multiple error messages while
      // attempting to recover from a detected syntax error.
      //
      // @see //inErrorRecoveryMode
      //

      this.errorRecoveryMode = false; // The index into the input stream where the last error occurred.
      // This is used to prevent infinite loops where an error is found
      // but no token is consumed during recovery...another error is found,
      // ad nauseum. This is a failsafe mechanism to guarantee that at least
      // one token/tree node is consumed for two errors.
      //

      this.lastErrorIndex = -1;
      this.lastErrorStates = null;
      return this;
    }

    DefaultErrorStrategy.prototype = Object.create(ErrorStrategy.prototype);
    DefaultErrorStrategy.prototype.constructor = DefaultErrorStrategy; // <p>The default implementation simply calls {@link //endErrorCondition} to
    // ensure that the handler is not in error recovery mode.</p>

    DefaultErrorStrategy.prototype.reset = function (recognizer) {
      this.endErrorCondition(recognizer);
    }; //
    // This method is called to enter error recovery mode when a recognition
    // exception is reported.
    //
    // @param recognizer the parser instance
    //


    DefaultErrorStrategy.prototype.beginErrorCondition = function (recognizer) {
      this.errorRecoveryMode = true;
    };

    DefaultErrorStrategy.prototype.inErrorRecoveryMode = function (recognizer) {
      return this.errorRecoveryMode;
    }; //
    // This method is called to leave error recovery mode after recovering from
    // a recognition exception.
    //
    // @param recognizer
    //


    DefaultErrorStrategy.prototype.endErrorCondition = function (recognizer) {
      this.errorRecoveryMode = false;
      this.lastErrorStates = null;
      this.lastErrorIndex = -1;
    }; //
    // {@inheritDoc}
    //
    // <p>The default implementation simply calls {@link //endErrorCondition}.</p>
    //


    DefaultErrorStrategy.prototype.reportMatch = function (recognizer) {
      this.endErrorCondition(recognizer);
    }; //
    // {@inheritDoc}
    //
    // <p>The default implementation returns immediately if the handler is already
    // in error recovery mode. Otherwise, it calls {@link //beginErrorCondition}
    // and dispatches the reporting task based on the runtime type of {@code e}
    // according to the following table.</p>
    //
    // <ul>
    // <li>{@link NoViableAltException}: Dispatches the call to
    // {@link //reportNoViableAlternative}</li>
    // <li>{@link InputMismatchException}: Dispatches the call to
    // {@link //reportInputMismatch}</li>
    // <li>{@link FailedPredicateException}: Dispatches the call to
    // {@link //reportFailedPredicate}</li>
    // <li>All other types: calls {@link Parser//notifyErrorListeners} to report
    // the exception</li>
    // </ul>
    //


    DefaultErrorStrategy.prototype.reportError = function (recognizer, e) {
      // if we've already reported an error and have not matched a token
      // yet successfully, don't report any errors.
      if (this.inErrorRecoveryMode(recognizer)) {
        return; // don't report spurious errors
      }

      this.beginErrorCondition(recognizer);

      if (e instanceof NoViableAltException) {
        this.reportNoViableAlternative(recognizer, e);
      } else if (e instanceof InputMismatchException) {
        this.reportInputMismatch(recognizer, e);
      } else if (e instanceof FailedPredicateException) {
        this.reportFailedPredicate(recognizer, e);
      } else {
        console.log("unknown recognition error type: " + e.constructor.name);
        console.log(e.stack);
        recognizer.notifyErrorListeners(e.getOffendingToken(), e.getMessage(), e);
      }
    }; //
    // {@inheritDoc}
    //
    // <p>The default implementation resynchronizes the parser by consuming tokens
    // until we find one in the resynchronization set--loosely the set of tokens
    // that can follow the current rule.</p>
    //


    DefaultErrorStrategy.prototype.recover = function (recognizer, e) {
      if (this.lastErrorIndex === recognizer.getInputStream().index && this.lastErrorStates !== null && this.lastErrorStates.indexOf(recognizer.state) >= 0) {
        // uh oh, another error at same token index and previously-visited
        // state in ATN; must be a case where LT(1) is in the recovery
        // token set so nothing got consumed. Consume a single token
        // at least to prevent an infinite loop; this is a failsafe.
        recognizer.consume();
      }

      this.lastErrorIndex = recognizer._input.index;

      if (this.lastErrorStates === null) {
        this.lastErrorStates = [];
      }

      this.lastErrorStates.push(recognizer.state);
      var followSet = this.getErrorRecoverySet(recognizer);
      this.consumeUntil(recognizer, followSet);
    }; // The default implementation of {@link ANTLRErrorStrategy//sync} makes sure
    // that the current lookahead symbol is consistent with what were expecting
    // at this point in the ATN. You can call this anytime but ANTLR only
    // generates code to check before subrules/loops and each iteration.
    //
    // <p>Implements Jim Idle's magic sync mechanism in closures and optional
    // subrules. E.g.,</p>
    //
    // <pre>
    // a : sync ( stuff sync )* ;
    // sync : {consume to what can follow sync} ;
    // </pre>
    //
    // At the start of a sub rule upon error, {@link //sync} performs single
    // token deletion, if possible. If it can't do that, it bails on the current
    // rule and uses the default error recovery, which consumes until the
    // resynchronization set of the current rule.
    //
    // <p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block
    // with an empty alternative), then the expected set includes what follows
    // the subrule.</p>
    //
    // <p>During loop iteration, it consumes until it sees a token that can start a
    // sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
    // stay in the loop as long as possible.</p>
    //
    // <p><strong>ORIGINS</strong></p>
    //
    // <p>Previous versions of ANTLR did a poor job of their recovery within loops.
    // A single mismatch token or missing token would force the parser to bail
    // out of the entire rules surrounding the loop. So, for rule</p>
    //
    // <pre>
    // classDef : 'class' ID '{' member* '}'
    // </pre>
    //
    // input with an extra token between members would force the parser to
    // consume until it found the next class definition rather than the next
    // member definition of the current class.
    //
    // <p>This functionality cost a little bit of effort because the parser has to
    // compare token set at the start of the loop and at each iteration. If for
    // some reason speed is suffering for you, you can turn off this
    // functionality by simply overriding this method as a blank { }.</p>
    //


    DefaultErrorStrategy.prototype.sync = function (recognizer) {
      // If already recovering, don't try to sync
      if (this.inErrorRecoveryMode(recognizer)) {
        return;
      }

      var s = recognizer._interp.atn.states[recognizer.state];
      var la = recognizer.getTokenStream().LA(1); // try cheaper subset first; might get lucky. seems to shave a wee bit off

      var nextTokens = recognizer.atn.nextTokens(s);

      if (nextTokens.contains(Token.EPSILON) || nextTokens.contains(la)) {
        return;
      }

      switch (s.stateType) {
        case ATNState.BLOCK_START:
        case ATNState.STAR_BLOCK_START:
        case ATNState.PLUS_BLOCK_START:
        case ATNState.STAR_LOOP_ENTRY:
          // report error and recover if possible
          if (this.singleTokenDeletion(recognizer) !== null) {
            return;
          } else {
            throw new InputMismatchException(recognizer);
          }

          break;

        case ATNState.PLUS_LOOP_BACK:
        case ATNState.STAR_LOOP_BACK:
          this.reportUnwantedToken(recognizer);
          var expecting = new IntervalSet();
          expecting.addSet(recognizer.getExpectedTokens());
          var whatFollowsLoopIterationOrRule = expecting.addSet(this.getErrorRecoverySet(recognizer));
          this.consumeUntil(recognizer, whatFollowsLoopIterationOrRule);
          break;

        default: // do nothing if we can't identify the exact kind of ATN state

      }
    }; // This is called by {@link //reportError} when the exception is a
    // {@link NoViableAltException}.
    //
    // @see //reportError
    //
    // @param recognizer the parser instance
    // @param e the recognition exception
    //


    DefaultErrorStrategy.prototype.reportNoViableAlternative = function (recognizer, e) {
      var tokens = recognizer.getTokenStream();
      var input;

      if (tokens !== null) {
        if (e.startToken.type === Token.EOF) {
          input = "<EOF>";
        } else {
          input = tokens.getText(new Interval(e.startToken.tokenIndex, e.offendingToken.tokenIndex));
        }
      } else {
        input = "<unknown input>";
      }

      var msg = "no viable alternative at input " + this.escapeWSAndQuote(input);
      recognizer.notifyErrorListeners(msg, e.offendingToken, e);
    }; //
    // This is called by {@link //reportError} when the exception is an
    // {@link InputMismatchException}.
    //
    // @see //reportError
    //
    // @param recognizer the parser instance
    // @param e the recognition exception
    //


    DefaultErrorStrategy.prototype.reportInputMismatch = function (recognizer, e) {
      var msg = "mismatched input " + this.getTokenErrorDisplay(e.offendingToken) + " expecting " + e.getExpectedTokens().toString(recognizer.literalNames, recognizer.symbolicNames);
      recognizer.notifyErrorListeners(msg, e.offendingToken, e);
    }; //
    // This is called by {@link //reportError} when the exception is a
    // {@link FailedPredicateException}.
    //
    // @see //reportError
    //
    // @param recognizer the parser instance
    // @param e the recognition exception
    //


    DefaultErrorStrategy.prototype.reportFailedPredicate = function (recognizer, e) {
      var ruleName = recognizer.ruleNames[recognizer._ctx.ruleIndex];
      var msg = "rule " + ruleName + " " + e.message;
      recognizer.notifyErrorListeners(msg, e.offendingToken, e);
    }; // This method is called to report a syntax error which requires the removal
    // of a token from the input stream. At the time this method is called, the
    // erroneous symbol is current {@code LT(1)} symbol and has not yet been
    // removed from the input stream. When this method returns,
    // {@code recognizer} is in error recovery mode.
    //
    // <p>This method is called when {@link //singleTokenDeletion} identifies
    // single-token deletion as a viable recovery strategy for a mismatched
    // input error.</p>
    //
    // <p>The default implementation simply returns if the handler is already in
    // error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to
    // enter error recovery mode, followed by calling
    // {@link Parser//notifyErrorListeners}.</p>
    //
    // @param recognizer the parser instance
    //


    DefaultErrorStrategy.prototype.reportUnwantedToken = function (recognizer) {
      if (this.inErrorRecoveryMode(recognizer)) {
        return;
      }

      this.beginErrorCondition(recognizer);
      var t = recognizer.getCurrentToken();
      var tokenName = this.getTokenErrorDisplay(t);
      var expecting = this.getExpectedTokens(recognizer);
      var msg = "extraneous input " + tokenName + " expecting " + expecting.toString(recognizer.literalNames, recognizer.symbolicNames);
      recognizer.notifyErrorListeners(msg, t, null);
    }; // This method is called to report a syntax error which requires the
    // insertion of a missing token into the input stream. At the time this
    // method is called, the missing token has not yet been inserted. When this
    // method returns, {@code recognizer} is in error recovery mode.
    //
    // <p>This method is called when {@link //singleTokenInsertion} identifies
    // single-token insertion as a viable recovery strategy for a mismatched
    // input error.</p>
    //
    // <p>The default implementation simply returns if the handler is already in
    // error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to
    // enter error recovery mode, followed by calling
    // {@link Parser//notifyErrorListeners}.</p>
    //
    // @param recognizer the parser instance
    //


    DefaultErrorStrategy.prototype.reportMissingToken = function (recognizer) {
      if (this.inErrorRecoveryMode(recognizer)) {
        return;
      }

      this.beginErrorCondition(recognizer);
      var t = recognizer.getCurrentToken();
      var expecting = this.getExpectedTokens(recognizer);
      var msg = "missing " + expecting.toString(recognizer.literalNames, recognizer.symbolicNames) + " at " + this.getTokenErrorDisplay(t);
      recognizer.notifyErrorListeners(msg, t, null);
    }; // <p>The default implementation attempts to recover from the mismatched input
    // by using single token insertion and deletion as described below. If the
    // recovery attempt fails, this method throws an
    // {@link InputMismatchException}.</p>
    //
    // <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
    //
    // <p>{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the
    // right token, however, then assume {@code LA(1)} is some extra spurious
    // token and delete it. Then consume and return the next token (which was
    // the {@code LA(2)} token) as the successful result of the match operation.</p>
    //
    // <p>This recovery strategy is implemented by {@link
    // //singleTokenDeletion}.</p>
    //
    // <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
    //
    // <p>If current token (at {@code LA(1)}) is consistent with what could come
    // after the expected {@code LA(1)} token, then assume the token is missing
    // and use the parser's {@link TokenFactory} to create it on the fly. The
    // "insertion" is performed by returning the created token as the successful
    // result of the match operation.</p>
    //
    // <p>This recovery strategy is implemented by {@link
    // //singleTokenInsertion}.</p>
    //
    // <p><strong>EXAMPLE</strong></p>
    //
    // <p>For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When
    // the parser returns from the nested call to {@code expr}, it will have
    // call chain:</p>
    //
    // <pre>
    // stat &rarr; expr &rarr; atom
    // </pre>
    //
    // and it will be trying to match the {@code ')'} at this point in the
    // derivation:
    //
    // <pre>
    // =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
    // ^
    // </pre>
    //
    // The attempt to match {@code ')'} will fail when it sees {@code ';'} and
    // call {@link //recoverInline}. To recover, it sees that {@code LA(1)==';'}
    // is in the set of tokens that can follow the {@code ')'} token reference
    // in rule {@code atom}. It can assume that you forgot the {@code ')'}.
    //


    DefaultErrorStrategy.prototype.recoverInline = function (recognizer) {
      // SINGLE TOKEN DELETION
      var matchedSymbol = this.singleTokenDeletion(recognizer);

      if (matchedSymbol !== null) {
        // we have deleted the extra token.
        // now, move past ttype token as if all were ok
        recognizer.consume();
        return matchedSymbol;
      } // SINGLE TOKEN INSERTION


      if (this.singleTokenInsertion(recognizer)) {
        return this.getMissingSymbol(recognizer);
      } // even that didn't work; must throw the exception


      throw new InputMismatchException(recognizer);
    }; //
    // This method implements the single-token insertion inline error recovery
    // strategy. It is called by {@link //recoverInline} if the single-token
    // deletion strategy fails to recover from the mismatched input. If this
    // method returns {@code true}, {@code recognizer} will be in error recovery
    // mode.
    //
    // <p>This method determines whether or not single-token insertion is viable by
    // checking if the {@code LA(1)} input symbol could be successfully matched
    // if it were instead the {@code LA(2)} symbol. If this method returns
    // {@code true}, the caller is responsible for creating and inserting a
    // token with the correct type to produce this behavior.</p>
    //
    // @param recognizer the parser instance
    // @return {@code true} if single-token insertion is a viable recovery
    // strategy for the current mismatched input, otherwise {@code false}
    //


    DefaultErrorStrategy.prototype.singleTokenInsertion = function (recognizer) {
      var currentSymbolType = recognizer.getTokenStream().LA(1); // if current token is consistent with what could come after current
      // ATN state, then we know we're missing a token; error recovery
      // is free to conjure up and insert the missing token

      var atn = recognizer._interp.atn;
      var currentState = atn.states[recognizer.state];
      var next = currentState.transitions[0].target;
      var expectingAtLL2 = atn.nextTokens(next, recognizer._ctx);

      if (expectingAtLL2.contains(currentSymbolType)) {
        this.reportMissingToken(recognizer);
        return true;
      } else {
        return false;
      }
    }; // This method implements the single-token deletion inline error recovery
    // strategy. It is called by {@link //recoverInline} to attempt to recover
    // from mismatched input. If this method returns null, the parser and error
    // handler state will not have changed. If this method returns non-null,
    // {@code recognizer} will <em>not</em> be in error recovery mode since the
    // returned token was a successful match.
    //
    // <p>If the single-token deletion is successful, this method calls
    // {@link //reportUnwantedToken} to report the error, followed by
    // {@link Parser//consume} to actually "delete" the extraneous token. Then,
    // before returning {@link //reportMatch} is called to signal a successful
    // match.</p>
    //
    // @param recognizer the parser instance
    // @return the successfully matched {@link Token} instance if single-token
    // deletion successfully recovers from the mismatched input, otherwise
    // {@code null}
    //


    DefaultErrorStrategy.prototype.singleTokenDeletion = function (recognizer) {
      var nextTokenType = recognizer.getTokenStream().LA(2);
      var expecting = this.getExpectedTokens(recognizer);

      if (expecting.contains(nextTokenType)) {
        this.reportUnwantedToken(recognizer); // print("recoverFromMismatchedToken deleting " \
        // + str(recognizer.getTokenStream().LT(1)) \
        // + " since " + str(recognizer.getTokenStream().LT(2)) \
        // + " is what we want", file=sys.stderr)

        recognizer.consume(); // simply delete extra token
        // we want to return the token we're actually matching

        var matchedSymbol = recognizer.getCurrentToken();
        this.reportMatch(recognizer); // we know current token is correct

        return matchedSymbol;
      } else {
        return null;
      }
    }; // Conjure up a missing token during error recovery.
    //
    // The recognizer attempts to recover from single missing
    // symbols. But, actions might refer to that missing symbol.
    // For example, x=ID {f($x);}. The action clearly assumes
    // that there has been an identifier matched previously and that
    // $x points at that token. If that token is missing, but
    // the next token in the stream is what we want we assume that
    // this token is missing and we keep going. Because we
    // have to return some token to replace the missing token,
    // we have to conjure one up. This method gives the user control
    // over the tokens returned for missing tokens. Mostly,
    // you will want to create something special for identifier
    // tokens. For literals such as '{' and ',', the default
    // action in the parser or tree parser works. It simply creates
    // a CommonToken of the appropriate type. The text will be the token.
    // If you change what tokens must be created by the lexer,
    // override this method to create the appropriate tokens.
    //


    DefaultErrorStrategy.prototype.getMissingSymbol = function (recognizer) {
      var currentSymbol = recognizer.getCurrentToken();
      var expecting = this.getExpectedTokens(recognizer);
      var expectedTokenType = expecting.first(); // get any element

      var tokenText;

      if (expectedTokenType === Token.EOF) {
        tokenText = "<missing EOF>";
      } else {
        tokenText = "<missing " + recognizer.literalNames[expectedTokenType] + ">";
      }

      var current = currentSymbol;
      var lookback = recognizer.getTokenStream().LT(-1);

      if (current.type === Token.EOF && lookback !== null) {
        current = lookback;
      }

      return recognizer.getTokenFactory().create(current.source, expectedTokenType, tokenText, Token.DEFAULT_CHANNEL, -1, -1, current.line, current.column);
    };

    DefaultErrorStrategy.prototype.getExpectedTokens = function (recognizer) {
      return recognizer.getExpectedTokens();
    }; // How should a token be displayed in an error message? The default
    // is to display just the text, but during development you might
    // want to have a lot of information spit out. Override in that case
    // to use t.toString() (which, for CommonToken, dumps everything about
    // the token). This is better than forcing you to override a method in
    // your token objects because you don't have to go modify your lexer
    // so that it creates a new Java type.
    //


    DefaultErrorStrategy.prototype.getTokenErrorDisplay = function (t) {
      if (t === null) {
        return "<no token>";
      }

      var s = t.text;

      if (s === null) {
        if (t.type === Token.EOF) {
          s = "<EOF>";
        } else {
          s = "<" + t.type + ">";
        }
      }

      return this.escapeWSAndQuote(s);
    };

    DefaultErrorStrategy.prototype.escapeWSAndQuote = function (s) {
      s = s.replace(/\n/g, "\\n");
      s = s.replace(/\r/g, "\\r");
      s = s.replace(/\t/g, "\\t");
      return "'" + s + "'";
    }; // Compute the error recovery set for the current rule. During
    // rule invocation, the parser pushes the set of tokens that can
    // follow that rule reference on the stack; this amounts to
    // computing FIRST of what follows the rule reference in the
    // enclosing rule. See LinearApproximator.FIRST().
    // This local follow set only includes tokens
    // from within the rule; i.e., the FIRST computation done by
    // ANTLR stops at the end of a rule.
    //
    // EXAMPLE
    //
    // When you find a "no viable alt exception", the input is not
    // consistent with any of the alternatives for rule r. The best
    // thing to do is to consume tokens until you see something that
    // can legally follow a call to r//or* any rule that called r.
    // You don't want the exact set of viable next tokens because the
    // input might just be missing a token--you might consume the
    // rest of the input looking for one of the missing tokens.
    //
    // Consider grammar:
    //
    // a : '[' b ']'
    // | '(' b ')'
    // ;
    // b : c '^' INT ;
    // c : ID
    // | INT
    // ;
    //
    // At each rule invocation, the set of tokens that could follow
    // that rule is pushed on a stack. Here are the various
    // context-sensitive follow sets:
    //
    // FOLLOW(b1_in_a) = FIRST(']') = ']'
    // FOLLOW(b2_in_a) = FIRST(')') = ')'
    // FOLLOW(c_in_b) = FIRST('^') = '^'
    //
    // Upon erroneous input "[]", the call chain is
    //
    // a -> b -> c
    //
    // and, hence, the follow context stack is:
    //
    // depth follow set start of rule execution
    // 0 <EOF> a (from main())
    // 1 ']' b
    // 2 '^' c
    //
    // Notice that ')' is not included, because b would have to have
    // been called from a different context in rule a for ')' to be
    // included.
    //
    // For error recovery, we cannot consider FOLLOW(c)
    // (context-sensitive or otherwise). We need the combined set of
    // all context-sensitive FOLLOW sets--the set of all tokens that
    // could follow any reference in the call chain. We need to
    // resync to one of those tokens. Note that FOLLOW(c)='^' and if
    // we resync'd to that token, we'd consume until EOF. We need to
    // sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}.
    // In this case, for input "[]", LA(1) is ']' and in the set, so we would
    // not consume anything. After printing an error, rule c would
    // return normally. Rule b would not find the required '^' though.
    // At this point, it gets a mismatched token error and throws an
    // exception (since LA(1) is not in the viable following token
    // set). The rule exception handler tries to recover, but finds
    // the same recovery set and doesn't consume anything. Rule b
    // exits normally returning to rule a. Now it finds the ']' (and
    // with the successful match exits errorRecovery mode).
    //
    // So, you can see that the parser walks up the call chain looking
    // for the token that was a member of the recovery set.
    //
    // Errors are not generated in errorRecovery mode.
    //
    // ANTLR's error recovery mechanism is based upon original ideas:
    //
    // "Algorithms + Data Structures = Programs" by Niklaus Wirth
    //
    // and
    //
    // "A note on error recovery in recursive descent parsers":
    // http://portal.acm.org/citation.cfm?id=947902.947905
    //
    // Later, Josef Grosch had some good ideas:
    //
    // "Efficient and Comfortable Error Recovery in Recursive Descent
    // Parsers":
    // ftp://www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip
    //
    // Like Grosch I implement context-sensitive FOLLOW sets that are combined
    // at run-time upon error to avoid overhead during parsing.
    //


    DefaultErrorStrategy.prototype.getErrorRecoverySet = function (recognizer) {
      var atn = recognizer._interp.atn;
      var ctx = recognizer._ctx;
      var recoverSet = new IntervalSet();

      while (ctx !== null && ctx.invokingState >= 0) {
        // compute what follows who invoked us
        var invokingState = atn.states[ctx.invokingState];
        var rt = invokingState.transitions[0];
        var follow = atn.nextTokens(rt.followState);
        recoverSet.addSet(follow);
        ctx = ctx.parentCtx;
      }

      recoverSet.removeOne(Token.EPSILON);
      return recoverSet;
    }; // Consume tokens until one matches the given token set.//


    DefaultErrorStrategy.prototype.consumeUntil = function (recognizer, set) {
      var ttype = recognizer.getTokenStream().LA(1);

      while (ttype !== Token.EOF && !set.contains(ttype)) {
        recognizer.consume();
        ttype = recognizer.getTokenStream().LA(1);
      }
    }; //
    // This implementation of {@link ANTLRErrorStrategy} responds to syntax errors
    // by immediately canceling the parse operation with a
    // {@link ParseCancellationException}. The implementation ensures that the
    // {@link ParserRuleContext//exception} field is set for all parse tree nodes
    // that were not completed prior to encountering the error.
    //
    // <p>
    // This error strategy is useful in the following scenarios.</p>
    //
    // <ul>
    // <li><strong>Two-stage parsing:</strong> This error strategy allows the first
    // stage of two-stage parsing to immediately terminate if an error is
    // encountered, and immediately fall back to the second stage. In addition to
    // avoiding wasted work by attempting to recover from errors here, the empty
    // implementation of {@link BailErrorStrategy//sync} improves the performance of
    // the first stage.</li>
    // <li><strong>Silent validation:</strong> When syntax errors are not being
    // reported or logged, and the parse result is simply ignored if errors occur,
    // the {@link BailErrorStrategy} avoids wasting work on recovering from errors
    // when the result will be ignored either way.</li>
    // </ul>
    //
    // <p>
    // {@code myparser.setErrorHandler(new BailErrorStrategy());}</p>
    //
    // @see Parser//setErrorHandler(ANTLRErrorStrategy)
    //


    function BailErrorStrategy() {
      DefaultErrorStrategy.call(this);
      return this;
    }

    BailErrorStrategy.prototype = Object.create(DefaultErrorStrategy.prototype);
    BailErrorStrategy.prototype.constructor = BailErrorStrategy; // Instead of recovering from exception {@code e}, re-throw it wrapped
    // in a {@link ParseCancellationException} so it is not caught by the
    // rule function catches. Use {@link Exception//getCause()} to get the
    // original {@link RecognitionException}.
    //

    BailErrorStrategy.prototype.recover = function (recognizer, e) {
      var context = recognizer._ctx;

      while (context !== null) {
        context.exception = e;
        context = context.parentCtx;
      }

      throw new ParseCancellationException(e);
    }; // Make sure we don't attempt to recover inline; if the parser
    // successfully recovers, it won't throw an exception.
    //


    BailErrorStrategy.prototype.recoverInline = function (recognizer) {
      this.recover(recognizer, new InputMismatchException(recognizer));
    }; // Make sure we don't attempt to recover from problems in subrules.//


    BailErrorStrategy.prototype.sync = function (recognizer) {// pass
    };

    exports.BailErrorStrategy = BailErrorStrategy;
    exports.DefaultErrorStrategy = DefaultErrorStrategy;
    /***/
  },

  /***/
  "./node_modules/antlr4/error/Errors.js":
  /*!*********************************************!*\
    !*** ./node_modules/antlr4/error/Errors.js ***!
    \*********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_error_ErrorsJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    // The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
    //  3 kinds of errors: prediction errors, failed predicate errors, and
    //  mismatched input errors. In each case, the parser knows where it is
    //  in the input, where it is in the ATN, the rule invocation stack,
    //  and what kind of problem occurred.
    var PredicateTransition = __webpack_require__(
    /*! ./../atn/Transition */
    "./node_modules/antlr4/atn/Transition.js").PredicateTransition;

    function RecognitionException(params) {
      Error.call(this);

      if (!!Error.captureStackTrace) {
        Error.captureStackTrace(this, RecognitionException);
      } else {
        var stack = new Error().stack;
      }

      this.message = params.message;
      this.recognizer = params.recognizer;
      this.input = params.input;
      this.ctx = params.ctx; // The current {@link Token} when an error occurred. Since not all streams
      // support accessing symbols by index, we have to track the {@link Token}
      // instance itself.

      this.offendingToken = null; // Get the ATN state number the parser was in at the time the error
      // occurred. For {@link NoViableAltException} and
      // {@link LexerNoViableAltException} exceptions, this is the
      // {@link DecisionState} number. For others, it is the state whose outgoing
      // edge we couldn't match.

      this.offendingState = -1;

      if (this.recognizer !== null) {
        this.offendingState = this.recognizer.state;
      }

      return this;
    }

    RecognitionException.prototype = Object.create(Error.prototype);
    RecognitionException.prototype.constructor = RecognitionException; // <p>If the state number is not known, this method returns -1.</p>
    //
    // Gets the set of input symbols which could potentially follow the
    // previously matched symbol at the time this exception was thrown.
    //
    // <p>If the set of expected tokens is not known and could not be computed,
    // this method returns {@code null}.</p>
    //
    // @return The set of token types that could potentially follow the current
    // state in the ATN, or {@code null} if the information is not available.
    // /

    RecognitionException.prototype.getExpectedTokens = function () {
      if (this.recognizer !== null) {
        return this.recognizer.atn.getExpectedTokens(this.offendingState, this.ctx);
      } else {
        return null;
      }
    };

    RecognitionException.prototype.toString = function () {
      return this.message;
    };

    function LexerNoViableAltException(lexer, input, startIndex, deadEndConfigs) {
      RecognitionException.call(this, {
        message: "",
        recognizer: lexer,
        input: input,
        ctx: null
      });
      this.startIndex = startIndex;
      this.deadEndConfigs = deadEndConfigs;
      return this;
    }

    LexerNoViableAltException.prototype = Object.create(RecognitionException.prototype);
    LexerNoViableAltException.prototype.constructor = LexerNoViableAltException;

    LexerNoViableAltException.prototype.toString = function () {
      var symbol = "";

      if (this.startIndex >= 0 && this.startIndex < this.input.size) {
        symbol = this.input.getText((this.startIndex, this.startIndex));
      }

      return "LexerNoViableAltException" + symbol;
    }; // Indicates that the parser could not decide which of two or more paths
    // to take based upon the remaining input. It tracks the starting token
    // of the offending input and also knows where the parser was
    // in the various paths when the error. Reported by reportNoViableAlternative()
    //


    function NoViableAltException(recognizer, input, startToken, offendingToken, deadEndConfigs, ctx) {
      ctx = ctx || recognizer._ctx;
      offendingToken = offendingToken || recognizer.getCurrentToken();
      startToken = startToken || recognizer.getCurrentToken();
      input = input || recognizer.getInputStream();
      RecognitionException.call(this, {
        message: "",
        recognizer: recognizer,
        input: input,
        ctx: ctx
      }); // Which configurations did we try at input.index() that couldn't match
      // input.LT(1)?//

      this.deadEndConfigs = deadEndConfigs; // The token object at the start index; the input stream might
      // not be buffering tokens so get a reference to it. (At the
      // time the error occurred, of course the stream needs to keep a
      // buffer all of the tokens but later we might not have access to those.)

      this.startToken = startToken;
      this.offendingToken = offendingToken;
    }

    NoViableAltException.prototype = Object.create(RecognitionException.prototype);
    NoViableAltException.prototype.constructor = NoViableAltException; // This signifies any kind of mismatched input exceptions such as
    // when the current input does not match the expected token.
    //

    function InputMismatchException(recognizer) {
      RecognitionException.call(this, {
        message: "",
        recognizer: recognizer,
        input: recognizer.getInputStream(),
        ctx: recognizer._ctx
      });
      this.offendingToken = recognizer.getCurrentToken();
    }

    InputMismatchException.prototype = Object.create(RecognitionException.prototype);
    InputMismatchException.prototype.constructor = InputMismatchException; // A semantic predicate failed during validation. Validation of predicates
    // occurs when normally parsing the alternative just like matching a token.
    // Disambiguating predicate evaluation occurs when we test a predicate during
    // prediction.

    function FailedPredicateException(recognizer, predicate, message) {
      RecognitionException.call(this, {
        message: this.formatMessage(predicate, message || null),
        recognizer: recognizer,
        input: recognizer.getInputStream(),
        ctx: recognizer._ctx
      });
      var s = recognizer._interp.atn.states[recognizer.state];
      var trans = s.transitions[0];

      if (trans instanceof PredicateTransition) {
        this.ruleIndex = trans.ruleIndex;
        this.predicateIndex = trans.predIndex;
      } else {
        this.ruleIndex = 0;
        this.predicateIndex = 0;
      }

      this.predicate = predicate;
      this.offendingToken = recognizer.getCurrentToken();
      return this;
    }

    FailedPredicateException.prototype = Object.create(RecognitionException.prototype);
    FailedPredicateException.prototype.constructor = FailedPredicateException;

    FailedPredicateException.prototype.formatMessage = function (predicate, message) {
      if (message !== null) {
        return message;
      } else {
        return "failed predicate: {" + predicate + "}?";
      }
    };

    function ParseCancellationException() {
      Error.call(this);
      Error.captureStackTrace(this, ParseCancellationException);
      return this;
    }

    ParseCancellationException.prototype = Object.create(Error.prototype);
    ParseCancellationException.prototype.constructor = ParseCancellationException;
    exports.RecognitionException = RecognitionException;
    exports.NoViableAltException = NoViableAltException;
    exports.LexerNoViableAltException = LexerNoViableAltException;
    exports.InputMismatchException = InputMismatchException;
    exports.FailedPredicateException = FailedPredicateException;
    exports.ParseCancellationException = ParseCancellationException;
    /***/
  },

  /***/
  "./node_modules/antlr4/error/index.js":
  /*!********************************************!*\
    !*** ./node_modules/antlr4/error/index.js ***!
    \********************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_error_indexJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    exports.RecognitionException = __webpack_require__(
    /*! ./Errors */
    "./node_modules/antlr4/error/Errors.js").RecognitionException;
    exports.NoViableAltException = __webpack_require__(
    /*! ./Errors */
    "./node_modules/antlr4/error/Errors.js").NoViableAltException;
    exports.LexerNoViableAltException = __webpack_require__(
    /*! ./Errors */
    "./node_modules/antlr4/error/Errors.js").LexerNoViableAltException;
    exports.InputMismatchException = __webpack_require__(
    /*! ./Errors */
    "./node_modules/antlr4/error/Errors.js").InputMismatchException;
    exports.FailedPredicateException = __webpack_require__(
    /*! ./Errors */
    "./node_modules/antlr4/error/Errors.js").FailedPredicateException;
    exports.DiagnosticErrorListener = __webpack_require__(
    /*! ./DiagnosticErrorListener */
    "./node_modules/antlr4/error/DiagnosticErrorListener.js").DiagnosticErrorListener;
    exports.BailErrorStrategy = __webpack_require__(
    /*! ./ErrorStrategy */
    "./node_modules/antlr4/error/ErrorStrategy.js").BailErrorStrategy;
    exports.ErrorListener = __webpack_require__(
    /*! ./ErrorListener */
    "./node_modules/antlr4/error/ErrorListener.js").ErrorListener;
    /***/
  },

  /***/
  "./node_modules/antlr4/index.js":
  /*!**************************************!*\
    !*** ./node_modules/antlr4/index.js ***!
    \**************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_indexJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    exports.atn = __webpack_require__(
    /*! ./atn/index */
    "./node_modules/antlr4/atn/index.js");
    exports.codepointat = __webpack_require__(
    /*! ./polyfills/codepointat */
    "./node_modules/antlr4/polyfills/codepointat.js");
    exports.dfa = __webpack_require__(
    /*! ./dfa/index */
    "./node_modules/antlr4/dfa/index.js");
    exports.fromcodepoint = __webpack_require__(
    /*! ./polyfills/fromcodepoint */
    "./node_modules/antlr4/polyfills/fromcodepoint.js");
    exports.tree = __webpack_require__(
    /*! ./tree/index */
    "./node_modules/antlr4/tree/index.js");
    exports.error = __webpack_require__(
    /*! ./error/index */
    "./node_modules/antlr4/error/index.js");
    exports.Token = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").Token;
    exports.CharStreams = __webpack_require__(
    /*! ./CharStreams */
    "./node_modules/antlr4/CharStreams.js").CharStreams;
    exports.CommonToken = __webpack_require__(
    /*! ./Token */
    "./node_modules/antlr4/Token.js").CommonToken;
    exports.InputStream = __webpack_require__(
    /*! ./InputStream */
    "./node_modules/antlr4/InputStream.js").InputStream;
    exports.FileStream = __webpack_require__(
    /*! ./FileStream */
    "./node_modules/antlr4/FileStream.js").FileStream;
    exports.CommonTokenStream = __webpack_require__(
    /*! ./CommonTokenStream */
    "./node_modules/antlr4/CommonTokenStream.js").CommonTokenStream;
    exports.Lexer = __webpack_require__(
    /*! ./Lexer */
    "./node_modules/antlr4/Lexer.js").Lexer;
    exports.Parser = __webpack_require__(
    /*! ./Parser */
    "./node_modules/antlr4/Parser.js").Parser;

    var pc = __webpack_require__(
    /*! ./PredictionContext */
    "./node_modules/antlr4/PredictionContext.js");

    exports.PredictionContextCache = pc.PredictionContextCache;
    exports.ParserRuleContext = __webpack_require__(
    /*! ./ParserRuleContext */
    "./node_modules/antlr4/ParserRuleContext.js").ParserRuleContext;
    exports.Interval = __webpack_require__(
    /*! ./IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval;
    exports.Utils = __webpack_require__(
    /*! ./Utils */
    "./node_modules/antlr4/Utils.js");
    /***/
  },

  /***/
  "./node_modules/antlr4/polyfills/codepointat.js":
  /*!******************************************************!*\
    !*** ./node_modules/antlr4/polyfills/codepointat.js ***!
    \******************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_polyfills_codepointatJs(module, exports) {
    /*! https://mths.be/codepointat v0.2.0 by @mathias */
    if (!String.prototype.codePointAt) {
      (function () {
        'use strict'; // needed to support `apply`/`call` with `undefined`/`null`

        var defineProperty = function () {
          // IE 8 only supports `Object.defineProperty` on DOM elements
          try {
            var object = {};
            var $defineProperty = Object.defineProperty;
            var result = $defineProperty(object, object, object) && $defineProperty;
          } catch (error) {}

          return result;
        }();

        var codePointAt = function codePointAt(position) {
          if (this == null) {
            throw TypeError();
          }

          var string = String(this);
          var size = string.length; // `ToInteger`

          var index = position ? Number(position) : 0;

          if (index != index) {
            // better `isNaN`
            index = 0;
          } // Account for out-of-bounds indices:


          if (index < 0 || index >= size) {
            return undefined;
          } // Get the first code unit


          var first = string.charCodeAt(index);
          var second;

          if ( // check if it’s the start of a surrogate pair
          first >= 0xD800 && first <= 0xDBFF && // high surrogate
          size > index + 1 // there is a next code unit
          ) {
            second = string.charCodeAt(index + 1);

            if (second >= 0xDC00 && second <= 0xDFFF) {
              // low surrogate
              // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
              return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
            }
          }

          return first;
        };

        if (defineProperty) {
          defineProperty(String.prototype, 'codePointAt', {
            'value': codePointAt,
            'configurable': true,
            'writable': true
          });
        } else {
          String.prototype.codePointAt = codePointAt;
        }
      })();
    }
    /***/

  },

  /***/
  "./node_modules/antlr4/polyfills/fromcodepoint.js":
  /*!********************************************************!*\
    !*** ./node_modules/antlr4/polyfills/fromcodepoint.js ***!
    \********************************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_polyfills_fromcodepointJs(module, exports) {
    /*! https://mths.be/fromcodepoint v0.2.1 by @mathias */
    if (!String.fromCodePoint) {
      (function () {
        var defineProperty = function () {
          // IE 8 only supports `Object.defineProperty` on DOM elements
          try {
            var object = {};
            var $defineProperty = Object.defineProperty;
            var result = $defineProperty(object, object, object) && $defineProperty;
          } catch (error) {}

          return result;
        }();

        var stringFromCharCode = String.fromCharCode;
        var floor = Math.floor;

        var fromCodePoint = function fromCodePoint(_) {
          var MAX_SIZE = 0x4000;
          var codeUnits = [];
          var highSurrogate;
          var lowSurrogate;
          var index = -1;
          var length = arguments.length;

          if (!length) {
            return '';
          }

          var result = '';

          while (++index < length) {
            var codePoint = Number(arguments[index]);

            if (!isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
            codePoint < 0 || // not a valid Unicode code point
            codePoint > 0x10FFFF || // not a valid Unicode code point
            floor(codePoint) != codePoint // not an integer
            ) {
              throw RangeError('Invalid code point: ' + codePoint);
            }

            if (codePoint <= 0xFFFF) {
              // BMP code point
              codeUnits.push(codePoint);
            } else {
              // Astral code point; split in surrogate halves
              // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
              codePoint -= 0x10000;
              highSurrogate = (codePoint >> 10) + 0xD800;
              lowSurrogate = codePoint % 0x400 + 0xDC00;
              codeUnits.push(highSurrogate, lowSurrogate);
            }

            if (index + 1 == length || codeUnits.length > MAX_SIZE) {
              result += stringFromCharCode.apply(null, codeUnits);
              codeUnits.length = 0;
            }
          }

          return result;
        };

        if (defineProperty) {
          defineProperty(String, 'fromCodePoint', {
            'value': fromCodePoint,
            'configurable': true,
            'writable': true
          });
        } else {
          String.fromCodePoint = fromCodePoint;
        }
      })();
    }
    /***/

  },

  /***/
  "./node_modules/antlr4/tree/Tree.js":
  /*!******************************************!*\
    !*** ./node_modules/antlr4/tree/Tree.js ***!
    \******************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_tree_TreeJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    ///
    // The basic notion of a tree has a parent, a payload, and a list of children.
    //  It is the most abstract interface for all the trees used by ANTLR.
    ///
    var Token = __webpack_require__(
    /*! ./../Token */
    "./node_modules/antlr4/Token.js").Token;

    var Interval = __webpack_require__(
    /*! ./../IntervalSet */
    "./node_modules/antlr4/IntervalSet.js").Interval;

    var INVALID_INTERVAL = new Interval(-1, -2);

    var Utils = __webpack_require__(
    /*! ../Utils.js */
    "./node_modules/antlr4/Utils.js");

    function Tree() {
      return this;
    }

    function SyntaxTree() {
      Tree.call(this);
      return this;
    }

    SyntaxTree.prototype = Object.create(Tree.prototype);
    SyntaxTree.prototype.constructor = SyntaxTree;

    function ParseTree() {
      SyntaxTree.call(this);
      return this;
    }

    ParseTree.prototype = Object.create(SyntaxTree.prototype);
    ParseTree.prototype.constructor = ParseTree;

    function RuleNode() {
      ParseTree.call(this);
      return this;
    }

    RuleNode.prototype = Object.create(ParseTree.prototype);
    RuleNode.prototype.constructor = RuleNode;

    function TerminalNode() {
      ParseTree.call(this);
      return this;
    }

    TerminalNode.prototype = Object.create(ParseTree.prototype);
    TerminalNode.prototype.constructor = TerminalNode;

    function ErrorNode() {
      TerminalNode.call(this);
      return this;
    }

    ErrorNode.prototype = Object.create(TerminalNode.prototype);
    ErrorNode.prototype.constructor = ErrorNode;

    function ParseTreeVisitor() {
      return this;
    }

    ParseTreeVisitor.prototype.visit = function (ctx) {
      if (Array.isArray(ctx)) {
        return ctx.map(function (child) {
          return child.accept(this);
        }, this);
      } else {
        return ctx.accept(this);
      }
    };

    ParseTreeVisitor.prototype.visitChildren = function (ctx) {
      return this.visit(ctx.children);
    };

    ParseTreeVisitor.prototype.visitTerminal = function (node) {};

    ParseTreeVisitor.prototype.visitErrorNode = function (node) {};

    function ParseTreeListener() {
      return this;
    }

    ParseTreeListener.prototype.visitTerminal = function (node) {};

    ParseTreeListener.prototype.visitErrorNode = function (node) {};

    ParseTreeListener.prototype.enterEveryRule = function (node) {};

    ParseTreeListener.prototype.exitEveryRule = function (node) {};

    function TerminalNodeImpl(symbol) {
      TerminalNode.call(this);
      this.parentCtx = null;
      this.symbol = symbol;
      return this;
    }

    TerminalNodeImpl.prototype = Object.create(TerminalNode.prototype);
    TerminalNodeImpl.prototype.constructor = TerminalNodeImpl;

    TerminalNodeImpl.prototype.getChild = function (i) {
      return null;
    };

    TerminalNodeImpl.prototype.getSymbol = function () {
      return this.symbol;
    };

    TerminalNodeImpl.prototype.getParent = function () {
      return this.parentCtx;
    };

    TerminalNodeImpl.prototype.getPayload = function () {
      return this.symbol;
    };

    TerminalNodeImpl.prototype.getSourceInterval = function () {
      if (this.symbol === null) {
        return INVALID_INTERVAL;
      }

      var tokenIndex = this.symbol.tokenIndex;
      return new Interval(tokenIndex, tokenIndex);
    };

    TerminalNodeImpl.prototype.getChildCount = function () {
      return 0;
    };

    TerminalNodeImpl.prototype.accept = function (visitor) {
      return visitor.visitTerminal(this);
    };

    TerminalNodeImpl.prototype.getText = function () {
      return this.symbol.text;
    };

    TerminalNodeImpl.prototype.toString = function () {
      if (this.symbol.type === Token.EOF) {
        return "<EOF>";
      } else {
        return this.symbol.text;
      }
    }; // Represents a token that was consumed during resynchronization
    // rather than during a valid match operation. For example,
    // we will create this kind of a node during single token insertion
    // and deletion as well as during "consume until error recovery set"
    // upon no viable alternative exceptions.


    function ErrorNodeImpl(token) {
      TerminalNodeImpl.call(this, token);
      return this;
    }

    ErrorNodeImpl.prototype = Object.create(TerminalNodeImpl.prototype);
    ErrorNodeImpl.prototype.constructor = ErrorNodeImpl;

    ErrorNodeImpl.prototype.isErrorNode = function () {
      return true;
    };

    ErrorNodeImpl.prototype.accept = function (visitor) {
      return visitor.visitErrorNode(this);
    };

    function ParseTreeWalker() {
      return this;
    }

    ParseTreeWalker.prototype.walk = function (listener, t) {
      var errorNode = t instanceof ErrorNode || t.isErrorNode !== undefined && t.isErrorNode();

      if (errorNode) {
        listener.visitErrorNode(t);
      } else if (t instanceof TerminalNode) {
        listener.visitTerminal(t);
      } else {
        this.enterRule(listener, t);

        for (var i = 0; i < t.getChildCount(); i++) {
          var child = t.getChild(i);
          this.walk(listener, child);
        }

        this.exitRule(listener, t);
      }
    }; //
    // The discovery of a rule node, involves sending two events: the generic
    // {@link ParseTreeListener//enterEveryRule} and a
    // {@link RuleContext}-specific event. First we trigger the generic and then
    // the rule specific. We to them in reverse order upon finishing the node.
    //


    ParseTreeWalker.prototype.enterRule = function (listener, r) {
      var ctx = r.getRuleContext();
      listener.enterEveryRule(ctx);
      ctx.enterRule(listener);
    };

    ParseTreeWalker.prototype.exitRule = function (listener, r) {
      var ctx = r.getRuleContext();
      ctx.exitRule(listener);
      listener.exitEveryRule(ctx);
    };

    ParseTreeWalker.DEFAULT = new ParseTreeWalker();
    exports.RuleNode = RuleNode;
    exports.ErrorNode = ErrorNode;
    exports.TerminalNode = TerminalNode;
    exports.ErrorNodeImpl = ErrorNodeImpl;
    exports.TerminalNodeImpl = TerminalNodeImpl;
    exports.ParseTreeListener = ParseTreeListener;
    exports.ParseTreeVisitor = ParseTreeVisitor;
    exports.ParseTreeWalker = ParseTreeWalker;
    exports.INVALID_INTERVAL = INVALID_INTERVAL;
    /***/
  },

  /***/
  "./node_modules/antlr4/tree/Trees.js":
  /*!*******************************************!*\
    !*** ./node_modules/antlr4/tree/Trees.js ***!
    \*******************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_tree_TreesJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    var Utils = __webpack_require__(
    /*! ./../Utils */
    "./node_modules/antlr4/Utils.js");

    var Token = __webpack_require__(
    /*! ./../Token */
    "./node_modules/antlr4/Token.js").Token;

    var RuleNode = __webpack_require__(
    /*! ./Tree */
    "./node_modules/antlr4/tree/Tree.js").RuleNode;

    var ErrorNode = __webpack_require__(
    /*! ./Tree */
    "./node_modules/antlr4/tree/Tree.js").ErrorNode;

    var TerminalNode = __webpack_require__(
    /*! ./Tree */
    "./node_modules/antlr4/tree/Tree.js").TerminalNode;

    var ParserRuleContext = __webpack_require__(
    /*! ./../ParserRuleContext */
    "./node_modules/antlr4/ParserRuleContext.js").ParserRuleContext;

    var RuleContext = __webpack_require__(
    /*! ./../RuleContext */
    "./node_modules/antlr4/RuleContext.js").RuleContext;

    var INVALID_ALT_NUMBER = __webpack_require__(
    /*! ./../atn/ATN */
    "./node_modules/antlr4/atn/ATN.js").INVALID_ALT_NUMBER;
    /** A set of utility routines useful for all kinds of ANTLR trees. */


    function Trees() {} // Print out a whole tree in LISP form. {@link //getNodeText} is used on the
    //  node payloads to get the text for the nodes.  Detect
    //  parse trees and extract data appropriately.


    Trees.toStringTree = function (tree, ruleNames, recog) {
      ruleNames = ruleNames || null;
      recog = recog || null;

      if (recog !== null) {
        ruleNames = recog.ruleNames;
      }

      var s = Trees.getNodeText(tree, ruleNames);
      s = Utils.escapeWhitespace(s, false);
      var c = tree.getChildCount();

      if (c === 0) {
        return s;
      }

      var res = "(" + s + ' ';

      if (c > 0) {
        s = Trees.toStringTree(tree.getChild(0), ruleNames);
        res = res.concat(s);
      }

      for (var i = 1; i < c; i++) {
        s = Trees.toStringTree(tree.getChild(i), ruleNames);
        res = res.concat(' ' + s);
      }

      res = res.concat(")");
      return res;
    };

    Trees.getNodeText = function (t, ruleNames, recog) {
      ruleNames = ruleNames || null;
      recog = recog || null;

      if (recog !== null) {
        ruleNames = recog.ruleNames;
      }

      if (ruleNames !== null) {
        if (t instanceof RuleContext) {
          var altNumber = t.getAltNumber();

          if (altNumber != INVALID_ALT_NUMBER) {
            return ruleNames[t.ruleIndex] + ":" + altNumber;
          }

          return ruleNames[t.ruleIndex];
        } else if (t instanceof ErrorNode) {
          return t.toString();
        } else if (t instanceof TerminalNode) {
          if (t.symbol !== null) {
            return t.symbol.text;
          }
        }
      } // no recog for rule names


      var payload = t.getPayload();

      if (payload instanceof Token) {
        return payload.text;
      }

      return t.getPayload().toString();
    }; // Return ordered list of all children of this node


    Trees.getChildren = function (t) {
      var list = [];

      for (var i = 0; i < t.getChildCount(); i++) {
        list.push(t.getChild(i));
      }

      return list;
    }; // Return a list of all ancestors of this node.  The first node of
    //  list is the root and the last is the parent of this node.
    //


    Trees.getAncestors = function (t) {
      var ancestors = [];
      t = t.getParent();

      while (t !== null) {
        ancestors = [t].concat(ancestors);
        t = t.getParent();
      }

      return ancestors;
    };

    Trees.findAllTokenNodes = function (t, ttype) {
      return Trees.findAllNodes(t, ttype, true);
    };

    Trees.findAllRuleNodes = function (t, ruleIndex) {
      return Trees.findAllNodes(t, ruleIndex, false);
    };

    Trees.findAllNodes = function (t, index, findTokens) {
      var nodes = [];

      Trees._findAllNodes(t, index, findTokens, nodes);

      return nodes;
    };

    Trees._findAllNodes = function (t, index, findTokens, nodes) {
      // check this node (the root) first
      if (findTokens && t instanceof TerminalNode) {
        if (t.symbol.type === index) {
          nodes.push(t);
        }
      } else if (!findTokens && t instanceof ParserRuleContext) {
        if (t.ruleIndex === index) {
          nodes.push(t);
        }
      } // check children


      for (var i = 0; i < t.getChildCount(); i++) {
        Trees._findAllNodes(t.getChild(i), index, findTokens, nodes);
      }
    };

    Trees.descendants = function (t) {
      var nodes = [t];

      for (var i = 0; i < t.getChildCount(); i++) {
        nodes = nodes.concat(Trees.descendants(t.getChild(i)));
      }

      return nodes;
    };

    exports.Trees = Trees;
    /***/
  },

  /***/
  "./node_modules/antlr4/tree/index.js":
  /*!*******************************************!*\
    !*** ./node_modules/antlr4/tree/index.js ***!
    \*******************************************/

  /*! no static exports found */

  /***/
  function _node_modules_antlr4_tree_indexJs(module, exports, __webpack_require__) {
    /* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
     * Use of this file is governed by the BSD 3-clause license that
     * can be found in the LICENSE.txt file in the project root.
     */
    var Tree = __webpack_require__(
    /*! ./Tree */
    "./node_modules/antlr4/tree/Tree.js");

    exports.Trees = __webpack_require__(
    /*! ./Trees */
    "./node_modules/antlr4/tree/Trees.js").Trees;
    exports.RuleNode = Tree.RuleNode;
    exports.ParseTreeListener = Tree.ParseTreeListener;
    exports.ParseTreeVisitor = Tree.ParseTreeVisitor;
    exports.ParseTreeWalker = Tree.ParseTreeWalker;
    /***/
  },

  /***/
  "./node_modules/debug/src/browser.js":
  /*!*******************************************!*\
    !*** ./node_modules/debug/src/browser.js ***!
    \*******************************************/

  /*! no static exports found */

  /***/
  function _node_modules_debug_src_browserJs(module, exports, __webpack_require__) {
    "use strict";

    function _typeof(obj) {
      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
        _typeof = function _typeof(obj) {
          return typeof obj;
        };
      } else {
        _typeof = function _typeof(obj) {
          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
        };
      }

      return _typeof(obj);
    }
    /* eslint-env browser */

    /**
     * This is the web browser implementation of `debug()`.
     */


    exports.log = log;
    exports.formatArgs = formatArgs;
    exports.save = save;
    exports.load = load;
    exports.useColors = useColors;
    exports.storage = localstorage();
    /**
     * Colors.
     */

    exports.colors = ['#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'];
    /**
     * Currently only WebKit-based Web Inspectors, Firefox >= v31,
     * and the Firebug extension (any Firefox version) are known
     * to support "%c" CSS customizations.
     *
     * TODO: add a `localStorage` variable to explicitly enable/disable colors
     */
    // eslint-disable-next-line complexity

    function useColors() {
      // NB: In an Electron preload script, document will be defined but not fully
      // initialized. Since we know we're in Chrome, we'll just detect this case
      // explicitly
      if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
        return true;
      } // Internet Explorer and Edge do not support colors.


      if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
        return false;
      } // Is webkit? http://stackoverflow.com/a/16459606/376773
      // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632


      return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
      typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
      typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
      typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
    }
    /**
     * Colorize log arguments if enabled.
     *
     * @api public
     */


    function formatArgs(args) {
      args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);

      if (!this.useColors) {
        return;
      }

      var c = 'color: ' + this.color;
      args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other
      // arguments passed either before or after the %c, so we need to
      // figure out the correct index to insert the CSS into

      var index = 0;
      var lastC = 0;
      args[0].replace(/%[a-zA-Z%]/g, function (match) {
        if (match === '%%') {
          return;
        }

        index++;

        if (match === '%c') {
          // We only are interested in the *last* %c
          // (the user may have provided their own)
          lastC = index;
        }
      });
      args.splice(lastC, 0, c);
    }
    /**
     * Invokes `console.log()` when available.
     * No-op when `console.log` is not a "function".
     *
     * @api public
     */


    function log() {
      var _console; // This hackery is required for IE8/9, where
      // the `console.log` function doesn't have 'apply'


      return (typeof console === "undefined" ? "undefined" : _typeof(console)) === 'object' && console.log && (_console = console).log.apply(_console, arguments);
    }
    /**
     * Save `namespaces`.
     *
     * @param {String} namespaces
     * @api private
     */


    function save(namespaces) {
      try {
        if (namespaces) {
          exports.storage.setItem('debug', namespaces);
        } else {
          exports.storage.removeItem('debug');
        }
      } catch (error) {// Swallow
        // XXX (@Qix-) should we be logging these?
      }
    }
    /**
     * Load `namespaces`.
     *
     * @return {String} returns the previously persisted debug modes
     * @api private
     */


    function load() {
      var r;

      try {
        r = exports.storage.getItem('debug');
      } catch (error) {} // Swallow
      // XXX (@Qix-) should we be logging these?
      // If debug isn't set in LS, and we're in Electron, try to load $DEBUG


      if (!r && typeof process !== 'undefined' && 'env' in process) {
        r = process.env.DEBUG;
      }

      return r;
    }
    /**
     * Localstorage attempts to return the localstorage.
     *
     * This is necessary because safari throws
     * when a user disables cookies/localstorage
     * and you attempt to access it.
     *
     * @return {LocalStorage}
     * @api private
     */


    function localstorage() {
      try {
        // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
        // The Browser also has localStorage in the global context.
        return localStorage;
      } catch (error) {// Swallow
        // XXX (@Qix-) should we be logging these?
      }
    }

    module.exports = __webpack_require__(
    /*! ./common */
    "./node_modules/debug/src/common.js")(exports);
    var formatters = module.exports.formatters;
    /**
     * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
     */

    formatters.j = function (v) {
      try {
        return JSON.stringify(v);
      } catch (error) {
        return '[UnexpectedJSONParseError]: ' + error.message;
      }
    };
    /***/

  },

  /***/
  "./node_modules/debug/src/common.js":
  /*!******************************************!*\
    !*** ./node_modules/debug/src/common.js ***!
    \******************************************/

  /*! no static exports found */

  /***/
  function _node_modules_debug_src_commonJs(module, exports, __webpack_require__) {
    "use strict";
    /**
     * This is the common logic for both the Node.js and web browser
     * implementations of `debug()`.
     */

    function setup(env) {
      createDebug.debug = createDebug;
      createDebug["default"] = createDebug;
      createDebug.coerce = coerce;
      createDebug.disable = disable;
      createDebug.enable = enable;
      createDebug.enabled = enabled;
      createDebug.humanize = __webpack_require__(
      /*! ms */
      "./node_modules/ms/index.js");
      Object.keys(env).forEach(function (key) {
        createDebug[key] = env[key];
      });
      /**
      * Active `debug` instances.
      */

      createDebug.instances = [];
      /**
      * The currently active debug mode names, and names to skip.
      */

      createDebug.names = [];
      createDebug.skips = [];
      /**
      * Map of special "%n" handling functions, for the debug "format" argument.
      *
      * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
      */

      createDebug.formatters = {};
      /**
      * Selects a color for a debug namespace
      * @param {String} namespace The namespace string for the for the debug instance to be colored
      * @return {Number|String} An ANSI color code for the given namespace
      * @api private
      */

      function selectColor(namespace) {
        var hash = 0;

        for (var i = 0; i < namespace.length; i++) {
          hash = (hash << 5) - hash + namespace.charCodeAt(i);
          hash |= 0; // Convert to 32bit integer
        }

        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
      }

      createDebug.selectColor = selectColor;
      /**
      * Create a debugger with the given `namespace`.
      *
      * @param {String} namespace
      * @return {Function}
      * @api public
      */

      function createDebug(namespace) {
        var prevTime;

        function debug() {
          // Disabled?
          if (!debug.enabled) {
            return;
          }

          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }

          var self = debug; // Set `diff` timestamp

          var curr = Number(new Date());
          var ms = curr - (prevTime || curr);
          self.diff = ms;
          self.prev = prevTime;
          self.curr = curr;
          prevTime = curr;
          args[0] = createDebug.coerce(args[0]);

          if (typeof args[0] !== 'string') {
            // Anything else let's inspect with %O
            args.unshift('%O');
          } // Apply any `formatters` transformations


          var index = 0;
          args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
            // If we encounter an escaped % then don't increase the array index
            if (match === '%%') {
              return match;
            }

            index++;
            var formatter = createDebug.formatters[format];

            if (typeof formatter === 'function') {
              var val = args[index];
              match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`

              args.splice(index, 1);
              index--;
            }

            return match;
          }); // Apply env-specific formatting (colors, etc.)

          createDebug.formatArgs.call(self, args);
          var logFn = self.log || createDebug.log;
          logFn.apply(self, args);
        }

        debug.namespace = namespace;
        debug.enabled = createDebug.enabled(namespace);
        debug.useColors = createDebug.useColors();
        debug.color = selectColor(namespace);
        debug.destroy = destroy;
        debug.extend = extend; // Debug.formatArgs = formatArgs;
        // debug.rawLog = rawLog;
        // env-specific initialization logic for debug instances

        if (typeof createDebug.init === 'function') {
          createDebug.init(debug);
        }

        createDebug.instances.push(debug);
        return debug;
      }

      function destroy() {
        var index = createDebug.instances.indexOf(this);

        if (index !== -1) {
          createDebug.instances.splice(index, 1);
          return true;
        }

        return false;
      }

      function extend(namespace, delimiter) {
        return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
      }
      /**
      * Enables a debug mode by namespaces. This can include modes
      * separated by a colon and wildcards.
      *
      * @param {String} namespaces
      * @api public
      */


      function enable(namespaces) {
        createDebug.save(namespaces);
        createDebug.names = [];
        createDebug.skips = [];
        var i;
        var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
        var len = split.length;

        for (i = 0; i < len; i++) {
          if (!split[i]) {
            // ignore empty strings
            continue;
          }

          namespaces = split[i].replace(/\*/g, '.*?');

          if (namespaces[0] === '-') {
            createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
          } else {
            createDebug.names.push(new RegExp('^' + namespaces + '$'));
          }
        }

        for (i = 0; i < createDebug.instances.length; i++) {
          var instance = createDebug.instances[i];
          instance.enabled = createDebug.enabled(instance.namespace);
        }
      }
      /**
      * Disable debug output.
      *
      * @api public
      */


      function disable() {
        createDebug.enable('');
      }
      /**
      * Returns true if the given mode name is enabled, false otherwise.
      *
      * @param {String} name
      * @return {Boolean}
      * @api public
      */


      function enabled(name) {
        if (name[name.length - 1] === '*') {
          return true;
        }

        var i;
        var len;

        for (i = 0, len = createDebug.skips.length; i < len; i++) {
          if (createDebug.skips[i].test(name)) {
            return false;
          }
        }

        for (i = 0, len = createDebug.names.length; i < len; i++) {
          if (createDebug.names[i].test(name)) {
            return true;
          }
        }

        return false;
      }
      /**
      * Coerce `val`.
      *
      * @param {Mixed} val
      * @return {Mixed}
      * @api private
      */


      function coerce(val) {
        if (val instanceof Error) {
          return val.stack || val.message;
        }

        return val;
      }

      createDebug.enable(createDebug.load());
      return createDebug;
    }

    module.exports = setup;
    /***/
  },

  /***/
  "./node_modules/ms/index.js":
  /*!**********************************!*\
    !*** ./node_modules/ms/index.js ***!
    \**********************************/

  /*! no static exports found */

  /***/
  function _node_modules_ms_indexJs(module, exports) {
    /**
     * Helpers.
     */
    var s = 1000;
    var m = s * 60;
    var h = m * 60;
    var d = h * 24;
    var w = d * 7;
    var y = d * 365.25;
    /**
     * Parse or format the given `val`.
     *
     * Options:
     *
     *  - `long` verbose formatting [false]
     *
     * @param {String|Number} val
     * @param {Object} [options]
     * @throws {Error} throw an error if val is not a non-empty string or a number
     * @return {String|Number}
     * @api public
     */

    module.exports = function (val, options) {
      options = options || {};
      var type = typeof val;

      if (type === 'string' && val.length > 0) {
        return parse(val);
      } else if (type === 'number' && isFinite(val)) {
        return options["long"] ? fmtLong(val) : fmtShort(val);
      }

      throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val));
    };
    /**
     * Parse the given `str` and return milliseconds.
     *
     * @param {String} str
     * @return {Number}
     * @api private
     */


    function parse(str) {
      str = String(str);

      if (str.length > 100) {
        return;
      }

      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);

      if (!match) {
        return;
      }

      var n = parseFloat(match[1]);
      var type = (match[2] || 'ms').toLowerCase();

      switch (type) {
        case 'years':
        case 'year':
        case 'yrs':
        case 'yr':
        case 'y':
          return n * y;

        case 'weeks':
        case 'week':
        case 'w':
          return n * w;

        case 'days':
        case 'day':
        case 'd':
          return n * d;

        case 'hours':
        case 'hour':
        case 'hrs':
        case 'hr':
        case 'h':
          return n * h;

        case 'minutes':
        case 'minute':
        case 'mins':
        case 'min':
        case 'm':
          return n * m;

        case 'seconds':
        case 'second':
        case 'secs':
        case 'sec':
        case 's':
          return n * s;

        case 'milliseconds':
        case 'millisecond':
        case 'msecs':
        case 'msec':
        case 'ms':
          return n;

        default:
          return undefined;
      }
    }
    /**
     * Short format for `ms`.
     *
     * @param {Number} ms
     * @return {String}
     * @api private
     */


    function fmtShort(ms) {
      var msAbs = Math.abs(ms);

      if (msAbs >= d) {
        return Math.round(ms / d) + 'd';
      }

      if (msAbs >= h) {
        return Math.round(ms / h) + 'h';
      }

      if (msAbs >= m) {
        return Math.round(ms / m) + 'm';
      }

      if (msAbs >= s) {
        return Math.round(ms / s) + 's';
      }

      return ms + 'ms';
    }
    /**
     * Long format for `ms`.
     *
     * @param {Number} ms
     * @return {String}
     * @api private
     */


    function fmtLong(ms) {
      var msAbs = Math.abs(ms);

      if (msAbs >= d) {
        return plural(ms, msAbs, d, 'day');
      }

      if (msAbs >= h) {
        return plural(ms, msAbs, h, 'hour');
      }

      if (msAbs >= m) {
        return plural(ms, msAbs, m, 'minute');
      }

      if (msAbs >= s) {
        return plural(ms, msAbs, s, 'second');
      }

      return ms + ' ms';
    }
    /**
     * Pluralization helper.
     */


    function plural(ms, msAbs, n, name) {
      var isPlural = msAbs >= n * 1.5;
      return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
    }
    /***/

  },

  /***/
  "./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/log-exceptions/log-exceptions.component.html":
  /*!***********************************************************************************************************************!*\
    !*** ./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/log-exceptions/log-exceptions.component.html ***!
    \***********************************************************************************************************************/

  /*! exports provided: default */

  /***/
  function _node_modules_rawLoader_dist_cjsJs_src_app_pages_home_logstab_logExceptions_logExceptionsComponentHtml(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony default export */


    __webpack_exports__["default"] = "<div class=\"p-grid p-align-center p-justify-between mb-8\">\n    <div class=\"p-grid p-align-center\">\n        <p-selectButton [options]=\"mostFrequent\" [(ngModel)]=\"selectMostFrequent\"\n            (onChange)=\"sortDataDescending()\"></p-selectButton>\n    </div>\n    <div class=\"p-grid p-align-center\">\n        <app-help  [helpFileName]=\"'logsException'\"  [helpTitle]=\"'EXCEPTIONS'\" [helpFolder]=\"'logMonitor'\" [helpClass]=\"'helpIcon'\"></app-help>\n    </div>\n</div>\n<br>\n<!-- exception table  -->\n<p-table [columns]=\"exceptionTableHeader\" [value]=\"exceptionTableData\" dataKey=\"Protocal\" [scrollable]=\"true\" scrollHeight=\"150px\" [rows]=\"10\" [paginator]=\"true\"\n    class=\"exceptiontable\">\n    <ng-template pTemplate=\"header\" let-columns>\n        <tr>\n            <th style=\"width: 3em\">#</th>\n            <th *ngFor=\"let col of columns\">\n                {{col.header}}\n            </th>\n        </tr> \n    </ng-template>    \n    <ng-template  pTemplate=\"body\" let-rowData let-expanded=\"expanded\" let-columns=\"columns\" let-row \n        let-rowIndex=\"rowIndex\">\n        <tr [ngClass]=\"row.exceptiontype == highlightedRow.exceptionType && row.loglevel ==  highlightedRow.logLevel ? 'selected-row' : ''\" (click)=\"executeRowClick(rowData,rowIndex)\" style=\"cursor: pointer\">\n            <td style=\"width: 3em\">\n                {{rowIndex+1}}\n            </td>\n            <td *ngFor=\"let col of columns\">\n                <span *ngIf=\"col.field == 'Exception'\"> {{rowData.exceptiontype}}</span>\n                <span *ngIf=\"col.field == 'Log'\"> {{rowData.loglevel}} </span>\n                <span *ngIf=\"col.field == 'count'\"> {{rowData['count 0']}} </span>\n                <span *ngIf=\"col.field == 'FirstOccurence'\"> {{rowData.first_occurence}} </span>\n                <span *ngIf=\"col.field == 'Last Seen'\">{{rowData.last_seen}}</span>\n            </td>\n        </tr>\n    </ng-template> \n    <ng-template pTemplate=\"emptymessage\" let-columns >\n        <tr>\n            <td  [attr.colspan]=\"columns.length + 1\" class=\"text-center\">\n                <span class=\"loader-container spinner\" *ngIf=\"exceptionTableLoading\">\n                    <i class=\"icons8 icons8-spinner spin\"></i>\n                </span>\n                <span *ngIf=\"noData\">\n                  Data is not available\n                </span>\n            </td>\n        </tr>\n    </ng-template>\n</p-table>\n<br>\n<div *ngIf=\"selectedRow && !noData\" >\n    <!-- for chart -->\n    <div  style=\"width: 'calc(100%-1385px)'; height: 400px; border: 1px solid #c8c8c8;\">\n        \n      <div class=\"loader-container spinner\" *ngIf=\"exceptionChartLoading\">\n        <i class=\"icons8 icons8-spinner spin\"></i>\n      </div>\n      \n      <div id=\"chartContainer\" *ngIf=\"!exceptionChartLoading\" style=\"max-width: 90%; margin:auto;\">\n                <app-visual-chart  [XaxisData]=\"XaxisData\" [YaxisData]=\"exceptionCount\" \n                [XaxisTitle]=\"exceptionName.toUpperCase()\" [YaxisTitle]=\"'COUNT'\" [logType]=\"logType\"> </app-visual-chart>\n      </div>  \n    </div>\n    <br>\n    <!-- for log data of exception -->\n    <p-table [value]=\"logTableData\" [columns]=\"logDataTableHeader\" [scrollable]=\"true\" scrollHeight=\"400px\">\n    <ng-template pTemplate=\"colgroup\">\n        <colgroup>\n            <col style=\"width:30%\">\n            <col style=\"width:70%\">\n        </colgroup>\n    </ng-template>\n    <ng-template pTemplate=\"header\" let-columns>\n        <tr>\n            <th *ngFor=\"let col of columns\">\n                {{col.header}}\n            </th>\n        </tr>\n    </ng-template>\n    <ng-template pTemplate=\"body\" let-columns=\"columns\" let-rowData>\n        <tr>\n            <td *ngFor=\"let col of columns; \">\n                <span *ngIf=\"col.field == 'Fields'\"> {{rowData.label}}</span>\n                <span *ngIf=\"col.field == 'Value'\"> {{rowData.value}}</span>\n            </td>\n        </tr>\n    </ng-template>\n    </p-table>\n</div>";
    /***/
  },

  /***/
  "./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/log-sequence-diagram/log-sequence-diagram.component.html":
  /*!***********************************************************************************************************************************!*\
    !*** ./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/log-sequence-diagram/log-sequence-diagram.component.html ***!
    \***********************************************************************************************************************************/

  /*! exports provided: default */

  /***/
  function _node_modules_rawLoader_dist_cjsJs_src_app_pages_home_logstab_logSequenceDiagram_logSequenceDiagramComponentHtml(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony default export */


    __webpack_exports__["default"] = "<div id=\"diagram\" style=\"zoom: .6;display:inline-block;width: 100%;\">\n <div *ngIf=\"isSequenceData == false\" style=\"width: 100%;text-align: center;\">\n    <span style=\"font-size: 20px;\">\n        Data Not Available\n    </span></div>\n</div>\n\n<p-dialog class=\"foterDialog\" header=\"Logs from :- {{startTime}} - {{endTime}}\"\n            [(visible)]=\"test\" *ngIf=\"test\" [style]=\"{'max-width':'900px'}\"\n            [baseZIndex]=\"10000\" modal=\"true\">\n            <p-table [scrollable]=\"true\" scrollHeight=\"300px\" [value]=\"logBlockData\">\n                <ng-template pTemplate=\"colgroup\" let-columns>\n                    <colgroup>\n                      <col class=\"width-110\"> \n                      <col class=\"width-80\"> \n                      <col class=\"p-col p-0\">\n                    </colgroup>\n                  </ng-template>\n                <ng-template pTemplate=\"header\">\n                    <tr>\n                        <th>Time</th>\n                        <th>Level</th>\n                        <th>Message</th>\n                    </tr>\n                </ng-template>\n                <ng-template pTemplate=\"body\" let-logblock>\n                    <tr>\n                        <td>{{getTimeValue(logblock.seqEvent.sourceStartTime)}}</td>\n                        <td>{{logblock.level}}</td>\n                        <td>{{logblock.message}}</td>\n                    </tr>\n                </ng-template>\n            </p-table>\n        </p-dialog>\n \n\n\n<!-- <div id=\"diagram\" style=\"zoom: .6;border: 3px solid black;\ndisplay:inline-block;\"></div>\n\n<p-dialog class=\"foterDialog\" header=\"logs\" [(visible)]=\"test\" *ngIf=\"test\" [style]=\"{'max-width':'500px'}\"\n    [baseZIndex]=\"10000\" modal=\"true\">\n    <p-table [value]=\"logBlockData\">\n        <ng-template pTemplate=\"header\">\n            <tr>\n                <th>Time</th>\n                <th>Level</th>\n                <th>Message</th>\n            </tr>\n        </ng-template>\n        <ng-template pTemplate=\"body\" let-logblock>\n            <tr>\n                <td>{{getTimeValue(logblock.seqEvent.sourceStartTime)}}</td>\n                <td>{{logblock.level}}</td>\n                <td>{{logblock.message}}</td>\n            </tr>\n        </ng-template>\n    </p-table>\n</p-dialog> -->";
    /***/
  },

  /***/
  "./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/logstab.component.html":
  /*!*************************************************************************************************!*\
    !*** ./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/logstab.component.html ***!
    \*************************************************************************************************/

  /*! exports provided: default */

  /***/
  function _node_modules_rawLoader_dist_cjsJs_src_app_pages_home_logstab_logstabComponentHtml(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony default export */


    __webpack_exports__["default"] = "<div class=\"breadcrumbs\" *ngIf=\"isFromDDR == true\">\n    <p-breadcrumb [model]=\"breadcrumb.getBreadcrumbMenu() | async\"\n        (inItemClick)=\"breadcrumb.handleBreadcrumbClick($event)\"></p-breadcrumb>\n</div>\n<div class=\"p-grid my-2 srcbar p-align-center w-100-p\">\n<div class=\"hitsCount p-col-2\">\n    <div pTooltip=\"{{title}}\" class=\"mx-1 elipseText width-125\" *ngIf=\"title\">{{title}}</div>\n    <div class=\"mx-5\">\n        <button *ngIf=\"showCacheButton && switchTab != 'exception'\" icon=\"icons8 icons8-back-arrow\" pButton (click)=\"cacheCall()\"\n            class=\"btn-icon\"></button>\n        {{convertNumberIntoFormat(hitsValue)}} hits\n    </div>\n</div>\n    <div class=\"p-col p-grid\">\n        <div class=\"type-search search-div-css\" style=\"width: 90%;\">\n            <p-autoComplete [(ngModel)]=\"reportitem\" [suggestions]=\"autoSuggestions\" (completeMethod)=\"filterFields($event)\" \n                (onSelect)=\"selectedSuggestion($event)\" placeholder=\"\" [minLength]=\"0\" class=\"input-field-search\" [dropdown]=\"false\"\n                (keydown.enter)=\"isSuggSelected==false && setAutoCompleteTextInQuery();searchData();\"\n                 inputId=\"searchQuery\" (keydown)=\"keyPress($event)\"\n                dropdownIcon=\"icons8 icons8-expand-arrow\" tooltipStyleClass=\"width-400 word-break\"\n                [ngClass]=\"isFieldValue ? 'autoSuggest' : ''\" pTooltip=\"{{searchbarVisibleQuery}}\" tooltipPosition=\"bottom\">\n            </p-autoComplete>\n        <button pButton [ngClass]=\"switchTab != 'exception' ? 'btn-icon right-icon mr-30 mtn-1' : 'btn-icon right-icon mr-15 mtn-1'\" icon=\"icons8 icons8-search\" [disabled]=\"searchVal\" pTooltip = \"Search\"\n        (click)=\"isSuggSelected==false && setAutoCompleteTextInQuery();searchData()\"></button>\n        <button pButton [ngClass]=\"switchTab != 'exception' ? 'btn-icon right-icon mr-15 mtn-1' : 'btn-icon right-icon mtn-1'\" icon=\"icons8 icons8-delete\" [disabled]=\"searchVal\" (click)=\"clearQuery()\" pTooltip = \"Clear\"></button>\n            <i class=\"las-list-solid clickable right-icon mtn-2 font-20 btn-icon\" *ngIf=\"switchTab != 'exception'\" (click)=\"showDialog()\" pTooltip = \"Open Saved Query\"></i>\n                <p-dialog [(visible)]=\"showSavedSearchDialog\" class=\"foterDialog\" header=\" Open Saved Log Query\" [resizable]=\"true\" [modal]=\"true\" [style]=\"{width: '40vw'}\">\n                    <cav-table\n                    [value]=\"saveSearchedData\" \n                    [headerRelativePath]=\"saveLogQueryHeaderrealtivePath\"\n                    (clickButtonEvent)=\"clickButtonEvent($event)\"\n                ></cav-table>\n                </p-dialog>\n        </div>\n        <app-help [helpFileName]=\"'logsHome'\" [helpTitle]=\"'LOGS'\" [helpFolder]=\"'logMonitor'\" [helpClass]=\"'helpIcon'\" ></app-help>\n        <button *ngIf=\"showClock\" pButton type=\"button\" class=\"btn-icon\" icon=\"icons8 icons8-clock\"  pTooltip=\"{{ gte + ' To ' + lte }}\"></button>\n    </div>\n<div class=\"p-grid p-align-center p-justify-end p-col-fixed\">\n    <ng-container *ngIf=\"(plus_arr.length > 0 ||minus_arr.length > 0 ||exist_arr.length > 0) && hitsValue != 0 && switchTab != 'exception'\">\n       <div class=\"mx-6\">Filter applied</div>\n        <div (click)=\"showFilter()\" class=\"showFilter p-6  p-grid p-align-center\">\n            <div style=\"white-space: nowrap;\n                    text-overflow: ellipsis;\n                    overflow: hidden;\" class=\"w-90-p pb-1\">\n                {{chipsValues[0].filterValue}}\n            </div>\n            <i [ngClass]=\"isFilterBarShowing == true ? 'icons8 icons8-collapse-arrow' : 'icons8 icons8-expand-arrow'\"></i>\n        </div>\n    </ng-container>\n    <button *ngIf=\"switchTab != 'exception'\" pButton class=\"btn-icon ml-5\" [pTooltip]=\"!histogramTable ? 'Table' : 'Histogram'\" (click)=\"histrogramToggle()\">\n        <i [ngClass]=\"!histogramTable ? 'las-th-list-solid' : 'icons8 icons8-bar-chart-2'\"></i>\n    </button>\n    <button pButton class=\"btn-icon\" icon=\"icons8 icons8-menu-vertical\" [disabled] = \"isMenu\" pTooltip=\"Open Menu\" [matMenuTriggerFor]=\"actionMenu\" iconPos=\"right\"></button>\n    <mat-menu #actionMenu=\"matMenu\">\n        <button mat-menu-item *ngIf=\"switchTab != 'exception'\" (click)=\"saveSearchData.open()\" [disabled]=\"userPermission == false\">Save Query</button>\n        <button mat-menu-item *ngIf=\"switchTab != 'exception' && isDedupChecked == false\" (click)=\"groupSimilerLogs()\" [disabled]=\"isGroupSimilar\">Group Similar Logs</button>\n        <button mat-menu-item *ngIf=\"switchTab != 'exception' && isDedupChecked == true\" (click)=\"groupSimilerLogs()\" >Ungroup Similar Logs</button>\n        <ng-container *ngFor=\"let item of actionOptions\">\n            <button *ngIf=\"switchTab != 'exception'\" (click)=\"getActionMenuItem(item.label)\"\n                mat-menu-item>{{\n                item.label }}</button>\n        </ng-container>\n        <button mat-menu-item [matMenuTriggerFor]=\"show\">Show</button>\n        <mat-menu #show=\"matMenu\">\n            <ng-container *ngFor=\"let item of showItems\">\n                <button *ngIf=\"(switchTab == 'exception' && item.label == 'Show Extracted Fields') == false\" (click)=\"getActionMenuItem(item.label)\"\n                    mat-menu-item>{{\n                    item.label }}</button>\n            </ng-container>\n        </mat-menu>\n        <button *ngIf=\"switchTab != 'exception'\" mat-menu-item [matMenuTriggerFor]=\"vertebrates\">Toggle Columns</button>\n        <div *ngIf=\"logStreamFlag\">\n            <button *ngIf=\"switchTab != 'exception'\" mat-menu-item (click)=\"openSequence()\">Show Sequence Diagram</button>\n        </div>\n    </mat-menu>\n    <p-dialog class=\"foterDialog\" header=\"Sequence Diagram ( Log Stream = {{logStreamValue}} )\"\n            [(visible)]=\"showSequence\" *ngIf=\"showSequence\" [style]=\"{'max-width':'1500px', 'max-height':'calc(100vh - 70px)'}\"\n            [baseZIndex]=\"10000\" modal=\"true\" [resizable]=\"false\">\n            <app-log-sequence-diagram></app-log-sequence-diagram>\n        </p-dialog>\n    <mat-menu #vertebrates=\"matMenu\">\n        <mat-checkbox class=\"mat-menu-item\" *ngFor=\"let column of toggleColumnOption; let i = index\"\n            [(ngModel)]=\"column.toggleColSelectedOption\" (change)=\"selectItems($event,column)\">{{column.label}}</mat-checkbox>\n    </mat-menu>\n</div>\n</div>\n<app-cav-loader *ngIf=\"logsCountLoading\" [top]=\"76\"></app-cav-loader>\n<div  *ngIf=\"showProgressBar\" class=\"p-grid p-align-center relative mb-5\">\n    <div class=\"progress\">\n        <span class=\"progressNumber\" *ngIf=\"displayProcessDoc\" pTooltip = \"Processed Count / Total Count\">{{convertNumberIntoFormat(processedCount)}}/{{convertNumberIntoFormat(totalCount)}}</span>\n        <p-progressBar [value]=\"(processedCount * 100)/totalCount\" [style]=\"{'height': '6px'}\"></p-progressBar>\n        <button pButton class=\"btn-icon right-icon mr-15 mtn-1\" icon=\"icons8 icons8-delete\" [style]=\"{'display':'block','margin':'auto','left':'3em','bottom':'1em'}\" [disabled]=\"!isCancelButtonDisable\" (click)=\"cancelPreviousQuery()\" pTooltip = \"Cancel\"></button>\n    </div>\n</div>\n<p-sidebar [(visible)]=\"showSavedExtractedField\" position=\"right\" [style]=\"{width:'520px'}\" [showCloseIcon]=\"false\">\n    <div class=\"sidebar-header\">\n        <div class=\"sidebar-title\">\n            <div>\n                <span>Saved Extracted Fields</span>\n            </div>\n            <div class=\"action-icons\">\n                <i class=\"icons8-delete\" (click)=\"showSavedExtractedField=false\" style = \"cursor: pointer;float:right;position: relative;bottom: 10px;\"></i>\n            </div>\n        </div>\n    </div>\n    <cav-table [value] = \"savedExtractFieldsList\" [headerRelativePath] = \"saveExtractFieldsHeaderRelativePath\" [scrollable]=\"true\" (clickButtonEvent)=\"editSavedRegularExp($event.cavEventExt.row)\" (deleteRow)=\"deleteSavedExtractField($event.row)\" scrollHeight=\"calc(100vh - 175px)\"></cav-table>\n</p-sidebar>\n<ng-container *ngIf=\"showRegex == true\">\n    <p-dialog [(visible)] = \"showRegex\" [resizable]=\"true\" [modal]=\"true\" class=\"foterDialog\" [draggable] = \"false\" (onHide) = \"closeExtractFieldDialog($event)\" header=\"Extracted Fields\">\n        <app-help  [helpFileName]=\"'logsExtractFields'\"  [helpTitle]=\"'EXTRACT FIELDS'\" [helpFolder]=\"'logMonitor'\" [helpClass]=\"'helpIcon'\" style=\"position:relative;float:right\"></app-help>\n        <div class=\"p-grid p-align-center\">\n        <div class=\"p-col\">\n            <div class=\"w-100-p pb-5\">Selected Expression</div>\n            <div class=\"w-100-p\">\n                <input type=\"text\" tooltipStyleClass=\"max-width-400 word-break\" pTooltip = \"{{extractFields?.selectedText}}\" class=\"w-100-p\" pInputText [(ngModel)]=\"extractFields.selectedText\" [readonly]=\"true\"/>\n            </div>\n        </div>\n        <div class=\"p-col\">\n            <div class=\"w-100-p pb-5\">Regular Expression</div>\n            <div class=\"w-100-p\">\n                <input type=\"text\" pTooltip = \"{{extractFields?.rex}}\" class=\"w-100-p\" pInputText [(ngModel)]=\"extractFields.rex\" [readonly]=\"!isEditExistExtractedField\"/>\n            </div>\n        </div>\n        <div class=\"p-col\">\n            <div class=\"w-100-p pb-5\">Source Type</div>\n            <div class=\"w-100-p\">\n                <input type=\"text\" pTooltip = \"{{extractFields?.selectedTextType}}\" class=\"w-100-p\" pInputText [(ngModel)]=\"extractFields.selectedTextType\" [readonly]=\"true\"/>\n            </div>\n        </div>\n        <div class=\"p-col\">\n            <div class=\"w-100-p pb-5\">Field Name</div>\n            <div class=\"w-100-p\">\n                <input type=\"text\" pTooltip = \"{{extractFields?.title}}\" class=\"w-100-p\" pInputText (keypress)=\"onKeyPress($event)\" [(ngModel)]=\"extractFields.title\"  maxlength=\"20\"/>\n            </div>\n        </div>\n        <div class=\"p-col-fixed\">\n            <button pButton type=\"button\" label=\"Preview\" [disabled]=\"extractFields.title.length < 3\" (click)=\"previewExtractField()\" class=\"btn-primary-outline mt-15\"></button>\n        </div>\n        <div class=\"p-col-fixed\">\n            <button pButton label=\"Save\" [disabled]=\"extractFields.title.length < 3 || userPermission == false\" (click)=\"saveExtractField()\" class=\"mt-15\"></button>\n        </div>\n        </div>\n        <div *ngIf = \"showSelectedLogMsg\" style = \"line-break:'anywhere';border: 1px solid;padding: 2px;\"> {{extractFields.selectedTextMsg}}</div>\n        <div class=\"p-5\" *ngIf = \"showMatchingLogs == true\">\n            <p-table [value]=\"similarSourceTypeMsg\" [columns] = \"matchingLogItem\" [scrollable]=\"true\" scrollHeight=\"400px\" [rows]=\"50\" [paginator]=\"true\">\n                <ng-template pTemplate=\"colgroup\" let-columns>\n                    <colgroup class = \"matchingLogItemColWidth\">\n                        <col *ngFor=\"let col of columns\">\n                    </colgroup>\n                </ng-template>\n                <ng-template pTemplate=\"header\" let-columns>\n                    <tr>\n                        <th *ngFor=\"let col of columns\">\n                            <span *ngIf = \"col.label == 'Message'\">{{col.label}}</span>\n                            <span *ngIf = \"col.label == ''\">{{extractFields.title}}</span>\n                        </th>\n                    </tr>\n                </ng-template>\n                <ng-template pTemplate=\"body\" let-row let-rowIndex=\"rowIndex\" let-columns=\"columns\">\n                    <tr>\n                        <td *ngFor=\"let col of columns\">\n                            <div style=\"max-height:350px;line-break:anywhere\" *ngIf = \"col.label == 'Message'\"> \n                                <span *ngIf=\"similarSourceTypeMsgMatchVal[rowIndex] == ''\">{{row}}</span>\n                                <ng-container *ngIf=\"similarSourceTypeMsgMatchVal[rowIndex] != ''\" >\n                                    <span> {{row.substring(0,row.indexOf(similarSourceTypeMsgMatchVal[rowIndex]))}} </span>\n                                    <span style = \"background-color: #ebf43d;color:black\"> {{row.substring(row.indexOf(similarSourceTypeMsgMatchVal[rowIndex]),row.indexOf(similarSourceTypeMsgMatchVal[rowIndex])+similarSourceTypeMsgMatchVal[rowIndex].length)}}</span>\n                                    <span> {{row.substring(row.indexOf(similarSourceTypeMsgMatchVal[rowIndex])+similarSourceTypeMsgMatchVal[rowIndex].length).trimStart()}}</span>\n                                </ng-container>    \n                            </div>\n                            <span *ngIf = \"col.label != 'Message'\" tooltipStyleClass=\"max-width-400 word-break\" pTooltip=\"{{row.substring(row.indexOf(similarSourceTypeMsgMatchVal[rowIndex]),row.indexOf(similarSourceTypeMsgMatchVal[rowIndex])+similarSourceTypeMsgMatchVal[rowIndex].length)}}\"> {{row.substring(row.indexOf(similarSourceTypeMsgMatchVal[rowIndex]),row.indexOf(similarSourceTypeMsgMatchVal[rowIndex])+similarSourceTypeMsgMatchVal[rowIndex].length)}} </span>\n                        </td>\n                    </tr>\n                </ng-template>\n                <ng-template pTemplate=\"emptymessage\" let-columns>\n                    <tr>\n                      <td [attr.colspan]=\"columns.length + 1\" class=\"text-center\">\n                        <span *ngIf=\"similarSourceTypeMsg.length == 0\">\n                          No Matching Found\n                        </span>\n                      </td>\n                    </tr>\n                  </ng-template>\n            </p-table>\n        </div>\n    </p-dialog>\n</ng-container>\n\n<div class=\"vertical-container\">\n    <div *ngIf=\"hitsValue==0 && showingNoResult\" class=\"px-100 pt-25\" style = \"overflow-y: scroll;height: 515px;\">\n        <app-no-result-found></app-no-result-found>\n    </div>\n    <div *ngIf=\"hitsValue!=0 || switchTab=='exception'\">\n<div class=\"p-grid p-align-center p-nogutter\"\n    *ngIf=\"isFilterBarShowing == true && (plus_arr.length > 0 ||minus_arr.length > 0 ||exist_arr.length > 0) && switchTab != 'exception'\">\n    <div class=\"w-100-p px-5 pb-5\">\n        <div class=\"ui-inputgroup\">\n            <p-chips [(ngModel)]=\"chipsValues\" class=\"tags-outer input-chips w-100-p\" (onRemove)=\"onRemoveTag($event)\">\n                <ng-template let-item pTemplate=\"item\">\n                    <span tooltipStyleClass=\"max-width-400 word-break\" pTooltip=\"{{item.filterValue}}\" *ngIf=\"item && item.chipType == 'plus'\" class=\"plusFilter\"> {{item.filterValue}} </span>\n                    <span tooltipStyleClass=\"max-width-400 word-break\" pTooltip=\"{{item.filterValue}}\" *ngIf=\"item && item.chipType == 'minus'\" class=\"minusFilter\"> {{item.filterValue}} </span>\n                    <span tooltipStyleClass=\"max-width-400word-break\" pTooltip=\"{{item.filterValue}}\" *ngIf=\"item && item.chipType == 'exist'\" class=\"existFilter\"> {{item.filterValue}} </span>\n                    <span style=\"margin: 10px;\"> </span>\n                </ng-template>\n            </p-chips>\n            <button pButton class=\"btn-icon\" icon=\"icons8 icons8-menu-vertical\" (click)=\"menu.toggle($event)\"></button>\n            <p-menu #menu [popup]=\"true\" styleClass=\"widget-menu\" [model]=\"menuOptions\"\n                [showTransitionOptions]=\"'0ms'\" [hideTransitionOptions]=\"'0ms'\"></p-menu>\n        </div>\n    </div>\n</div>\n        <div (rowClick)=\"serviceMethodTiming($event)\" class=\"side-bar-wrapper mySlider\">\n            <div class=\"p-4 relative\" class=\"sidebar-nav new-width\" [ngClass]=\"fieldExpandedDiv == true ? '' : 'active'\">\n                <app-log-integration \n                *ngIf=\"fieldsdata\" [fieldsArray]=\"fieldsdata\" [filterVal]='filtervalue' [isDisable] = \"isDisableAll\"\n                    (field)=\"addTableColumn($event)\" (removeField)=\"deleteTableColumn($event)\" (plus_paramsObject)='plus_filter($event)'\n                    (minus_paramsObject)='minus_filter($event)' (pairs)='copyTextFilter($event)' [isDisable]=\"isDisableAll\"></app-log-integration>\n                <button *ngIf=\"switchTab != 'exception'\" class=\"sidebar-toggler\" pTooltip=\"{{fieldExpandedDiv == true ? 'Hide' : 'Expand'}}\" (click)=\"toggle()\"><i class=\"icons8\" [ngClass]=\"fieldExpandedDiv == true ? 'icons8-back' : 'icons8-forward'\"></i></button>\n            </div>\n            <div class=\"side-bar-content mt-0\">\n                <div class=\"p-grid w-100-p\">\n                    <div class=\"w-100-p px-6 relative relative\">\n                        <div class=\"tabs-data\">\n                            <div *ngIf=\"showExpandedDiv\" class=\"tab-content\">\n                                <button pButton class=\"btn-icon m-2 histogramClose\" icon=\"las-times-circle\" (click)=\"closeItem()\"\n                                pTooltip=\"Close\"></button>\n                                <div *ngIf=\"histogramTable == false && isHistogramToggle == true\">\n                                    <app-visual-chart [XaxisData]='chartXaxisData' [YaxisData]='chartYaxisData'\n                                        (zoomchanges)='zoomfun($event)' [XaxisTitle]='\"@TIMESTAMP\"'\n                                        [YaxisTitle]='\"COUNT\"' [ZoomValid] = \"isZoom\" [zoomArr] = \"getTimeValuesBeforeZoom\" [fieldExpandedDiv] = \"fieldExpandedDiv\"></app-visual-chart>\n                                </div>\n                                <div *ngIf=\"histogramTable == true && isHistogramToggle == true\">\n                                    <app-visual-table [tableData]='tabledata'></app-visual-table>\n                                </div>\n                                <div *ngIf=\"isRequest == true && isActionOption == true\">\n                                    <app-visual-request [switchTab]=\"switchTab\"></app-visual-request>\n                                </div>\n                                <div *ngIf=\"isResponse == true && isActionOption == true\">\n                                    <app-visual-response [respdata]='data.data'></app-visual-response>\n                                </div>\n                                <div *ngIf=\"isStatistic == true && isActionOption == true\">\n                                    <app-visual-statistics [statsData]=\"stats\"></app-visual-statistics>\n                                </div>\n                            </div>\n                        </div>\n                        <div class=\"w-100-p\">                              \n                            <p-tabView (onChange)=\"tabclick($event)\">\n                            <p-tabPanel header=\"LOGS DETAILS\">\n                                <div class=\"table-container\">\n                                    <p-table [resizableColumns]=\"true\" [value]=\"data.data.tableData\" [rows]=\"50\" [paginator]=\"true\"\n                                        [(first)]=\"first\" [columns]=\"data.headers[0].cols\" [reorderableColumns]=\"true\" rowExpandMode=\"single\"\n                                        dataKey=\"no\" class=\"all-tables\" [scrollable]=\"true\" [scrollHeight]=\"tableHeight + 'px'\"\n                                        [expandedRowKeys]=\"expandedRows\">\n                                        <ng-template pTemplate=\"colgroup\" let-columns>\n                                            <colgroup class=\"colWidth12\">\n                                                <col *ngFor=\"let col of columns;let i = index;\" class=\"{{col.classes}}\">\n                                            </colgroup>\n                                        </ng-template>\n                                        <ng-template pTemplate=\"header\" let-columns>\n                                            <tr>\n                                                <th *ngFor=\"let col of columns;let i = index\" pSortableColumn=\"{{col.valueField}}\" pResizableColumn\n                                                    pReorderableColumn (click)=\"sorting_order(col.valueField)\">\n                                                    <div class=\"p-grid p-align-center p-justify-center\">\n                                                        <div pTooltip=\"{{ col.label }}\">{{ col.label }}</div>\n                                                        <p-sortIcon\n                                                            *ngIf=\"col.label != 'Diff(ms)' && col.label != 'Count' && col.label != 'Log Information' && col.label != '' && col.label != 'Elapsed(ms)'\"\n                                                            field=\"{{col.valueField}}\" class=\"right\" ariaLabel=\"Activate to sort\"\n                                                            ariaLabelDesc=\"Activate to sort in descending order\"\n                                                            ariaLabelAsc=\"Activate to sort in ascending order\">\n                                                        </p-sortIcon>\n                                                    </div>\n                                                </th>\n                                            </tr>\n                                        </ng-template>\n                                        <ng-template pTemplate=\"body\" let-expanded=\"expanded\" let-row let-rowIndex=\"rowIndex\" let-columns=\"columns\">\n                                            <tr>\n                                                <td *ngFor=\"let col of columns\" class=\"relative\" [ngClass]=\"col.classes\">\n                                                    <div [ngClass]=\"selectRow[row.no]==1 ? 'heightExpand' : 'height' \"\n                                                        [ngStyle]=\"selectRow[row.no]==0 ? {'max-height' : 14 * messageLength + 'px'} : {}\">\n                                                        <span (mouseup)=\"menu($event,row)\" *ngIf=\"col.badgeField\">\n                                                            <ng-container *ngFor=\"let item of row.responseBtns\" class=\"clickable\">\n                                                                <span\n                                                                    *ngIf=\"isCreateTable==false && item.label!='<br>' && selectRow[row.no]==0 && item.value == 'perf_request'\"\n                                                                    class=\"badge {{item.color}}\"\n                                                                    (click)=\"copyLabel(item.label+':'+item.value,true)\">\n                                                                    {{item.label}}:{{item.value}}\n                                                                </span>\n                                                                <span\n                                                                    *ngIf=\"isCreateTable==false && item.label!='<br>' && selectRow[row.no]==1 && item.label.includes('message') == false && item.label != '_index'\"\n                                                                    class=\"badge {{item.color}} clickable\"\n                                                                    (click)=\"copyLabel(item.label+':'+item.value,true)\">\n                                                                    {{item.label}}:{{item.value}}\n                                                                </span>\n                                                                <span\n                                                                    *ngIf=\"isCreateTable == false && isCustomTable==false && item.label != '<br>' && selectRow[row.no] == 0 && item.label.includes('message') && similerLogHiglight == false\"\n                                                                    style=\"margin-right: 20px;text-overflow: ellipsis;width: 85%;line-break: anywhere;\">\n                                                                    <ng-container *ngIf=\"item.value.includes('ERROR')\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('ERROR')))\"></span>\n                                                                        <span style=\"background-color: red;\">\n                                                                            {{item.value.substring(item.value.indexOf('ERROR'),item.value.indexOf('ERROR')\n                                                                            + 5)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('ERROR') + 5)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container\n                                                                        *ngIf=\"item.value.includes('WARN') == true && item.value.substring(item.value.indexOf('WARN')+4).startsWith('ING') == false\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                        <span style=\"background-color: yellow;\">\n                                                                            {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARN')\n                                                                            + 4)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('WARN') + 4)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container *ngIf=\"item.value.includes('WARNING')\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                        <span style=\"background-color: yellow;\">\n                                                                            {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARNING')\n                                                                            + 7)}} </span>\n                                                                        <span [innerHTML]=\"item.value.substring(item.value.indexOf('WARNING') + 7)\">\n                                                                        </span>\n                                                                    </ng-container>\n                                                                    <ng-container\n                                                                        *ngIf=\"item.value.includes('ERROR') == false && item.value.includes('WARN') == false && item.value.includes('WARNING') == false\">\n                                                                        <span [innerHTML]=\"item.value\"></span>\n                                                                    </ng-container>\n                                                                </span>\n                                                                <span\n                                                                    *ngIf=\"isCreateTable == false && isCustomTable==false && item.label != '<br>' && selectRow[row.no] == 0 && item.label.includes('message') && similerLogHiglight == true && item.value != similerMessage\"\n                                                                    style=\"margin-right: 21px;text-overflow: ellipsis;width: 85%;\">\n                                                                    <ng-container *ngIf=\"item.value.includes('ERROR')\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('ERROR')))\"></span>\n                                                                        <span style=\"background-color: red;\">\n                                                                            {{item.value.substring(item.value.indexOf('ERROR'),item.value.indexOf('ERROR')\n                                                                            + 5)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('ERROR') + 5)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container\n                                                                        *ngIf=\"item.value.includes('WARN') == true && item.value.substring(item.value.indexOf('WARN')+4).startsWith('ING') == false\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                        <span style=\"background-color: yellow;\">\n                                                                            {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARN')\n                                                                            + 4)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('WARN') + 4)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container *ngIf=\"item.value.includes('WARNING')\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                        <span style=\"background-color: yellow;\">\n                                                                            {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARNING')\n                                                                            + 7)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('WARNING') + 7)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container\n                                                                        *ngIf=\"item.value.includes('ERROR') == false && item.value.includes('WARN') == false && item.value.includes('WARNING') == false\">\n                                                                        <span [innerHTML]=\"item.value\"></span>\n                                                                    </ng-container>\n                                                                </span>\n                                                                <mark class=\"markClsass\"\n                                                                    *ngIf=\"similerLogHiglight == true && item.value == similerMessage\">\n                                                                    <span\n                                                                        *ngIf=\"isCreateTable == false && isCustomTable==false && item.label != '<br>' && selectRow[row.no] == 0 && item.label.includes('message')\"\n                                                                        style=\"margin-right: 22px;   text-overflow: ellipsis ;width: 85%;\">\n                                                                        <ng-container *ngIf=\"item.value.includes('ERROR')\">\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(0,(item.value.indexOf('ERROR')))\"></span>\n                                                                            <span style=\"background-color: red;\">\n                                                                                {{item.value.substring(item.value.indexOf('ERROR'),item.value.indexOf('ERROR')\n                                                                                + 5)}} </span>\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(item.value.indexOf('ERROR') + 5)\"></span>\n                                                                        </ng-container>\n                                                                        <ng-container\n                                                                            *ngIf=\"item.value.includes('WARN') == true && item.value.substring(item.value.indexOf('WARN')+4).startsWith('ING') == false\">\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                            <span style=\"background-color: yellow;\">\n                                                                                {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARN')\n                                                                                + 4)}} </span>\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(item.value.indexOf('WARN') + 4)\"></span>\n                                                                        </ng-container>\n                                                                        <ng-container *ngIf=\"item.value.includes('WARNING')\">\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                            <span style=\"background-color: yellow;\">\n                                                                                {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARNING')\n                                                                                + 7)}} </span>\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(item.value.indexOf('WARNING') + 7)\"></span>\n                                                                        </ng-container>\n                                                                        <ng-container\n                                                                            *ngIf=\"item.value.includes('ERROR') == false && item.value.includes('WARN') == false && item.value.includes('WARNING') == false\">\n                                                                            <span [innerHTML]=\"item.value\"></span>\n                                                                        </ng-container>\n                            \n                                                                    </span>\n                                                                </mark>\n                                                                <span\n                                                                    *ngIf=\"isCreateTable == false && isCustomTable==false && item.label != '<br>' && selectRow[row.no] == 1 && item.label == 'message' && item.value != '' \"\n                                                                    (click)=\"copyLabel(item.label+':'+item.value,true)\">\n                                                                    <b class=\"bg-neutral-300 d-bg-neutral-700\">{{item.label}}:</b>\n                                                                </span>\n                                                                <span\n                                                                    *ngIf=\"isCreateTable == false && isCustomTable==false && item.label != '<br>' && selectRow[row.no] == 1 && item.label.includes('message') && similerLogHiglight == false\"\n                                                                    style=\"margin-right: 20px;line-height: 21px; line-break: anywhere;\">\n                                                                    <ng-container *ngIf=\"item.value.includes('ERROR')\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('ERROR')))\"></span>\n                                                                        <span style=\"background-color: red;\">\n                                                                            {{item.value.substring(item.value.indexOf('ERROR'),item.value.indexOf('ERROR')\n                                                                            + 5)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('ERROR') + 5)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container\n                                                                        *ngIf=\"item.value.includes('WARN') == true && item.value.substring(item.value.indexOf('WARN')+4).startsWith('ING') == false\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                        <span style=\"background-color: yellow;\">\n                                                                            {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARN')\n                                                                            + 4)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('WARN') + 4)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container *ngIf=\"item.value.includes('WARNING')\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                        <span style=\"background-color: yellow;\">\n                                                                            {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARNING')\n                                                                            + 7)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('WARNING') + 7)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container\n                                                                        *ngIf=\"item.value.includes('ERROR') == false && item.value.includes('WARN') == false && item.value.includes('WARNING') == false\">\n                                                                        <span [innerHTML]=\"item.value\"></span>\n                                                                    </ng-container>\n                                                                </span>\n                                                                <span\n                                                                    *ngIf=\"isCreateTable == false && isCustomTable==false && item.label != '<br>' && selectRow[row.no] == 1 && item.label.includes('message') && similerLogHiglight == true && item.value != similerMessage\"\n                                                                    style=\"margin-right: 21px;text-overflow: ellipsis;width: 85%;\">\n                                                                    <ng-container *ngIf=\"item.value.includes('ERROR')\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('ERROR')))\"></span>\n                                                                        <span style=\"background-color: red;\">\n                                                                            {{item.value.substring(item.value.indexOf('ERROR'),item.value.indexOf('ERROR')\n                                                                            + 5)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('ERROR') + 5)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container\n                                                                        *ngIf=\"item.value.includes('WARN') == true && item.value.substring(item.value.indexOf('WARN')+4).startsWith('ING') == false\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                        <span style=\"background-color: yellow;\">\n                                                                            {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARN')\n                                                                            + 4)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('WARN') + 4)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container *ngIf=\"item.value.includes('WARNING')\">\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                        <span style=\"background-color: yellow;\">\n                                                                            {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARNING')\n                                                                            + 7)}} </span>\n                                                                        <span\n                                                                            [innerHTML]=\"item.value.substring(item.value.indexOf('WARNING') + 7)\"></span>\n                                                                    </ng-container>\n                                                                    <ng-container\n                                                                        *ngIf=\"item.value.includes('ERROR') == false && item.value.includes('WARN') == false && item.value.includes('WARNING') == false\">\n                                                                        <span [innerHTML]=\"item.value\"></span>\n                                                                    </ng-container>\n                                                                </span>\n                                                                <mark class=\"markClsassExpand\"\n                                                                    *ngIf=\"similerLogHiglight == true && item.value == similerMessage\">\n                                                                    <span\n                                                                        *ngIf=\"isCreateTable == false && isCustomTable==false && item.label != '<br>' && selectRow[row.no] == 1 && item.label.includes('message')\"\n                                                                        style=\"margin-right: 20px;line-height: 21px;line-break: anywhere;\">\n                                                                        <ng-container *ngIf=\"item.value.includes('ERROR')\">\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(0,(item.value.indexOf('ERROR')))\"></span>\n                                                                            <span style=\"background-color: red;\">\n                                                                                {{item.value.substring(item.value.indexOf('ERROR'),item.value.indexOf('ERROR')\n                                                                                + 5)}} </span>\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(item.value.indexOf('ERROR') + 5)\"></span>\n                                                                        </ng-container>\n                                                                        <ng-container\n                                                                            *ngIf=\"item.value.includes('WARN') == true && item.value.substring(item.value.indexOf('WARN')+4).startsWith('ING') == false\">\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                            <span style=\"background-color: yellow;\">\n                                                                                {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARN')\n                                                                                + 4)}} </span>\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(item.value.indexOf('WARN') + 4)\"></span>\n                                                                        </ng-container>\n                                                                        <ng-container *ngIf=\"item.value.includes('WARNING')\">\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(0,(item.value.indexOf('WARN')))\"></span>\n                                                                            <span style=\"background-color: yellow;\">\n                                                                                {{item.value.substring(item.value.indexOf('WARN'),item.value.indexOf('WARNING')\n                                                                                + 7)}} </span>\n                                                                            <span\n                                                                                [innerHTML]=\"item.value.substring(item.value.indexOf('WARNING') + 7)\"></span>\n                                                                        </ng-container>\n                                                                        <ng-container\n                                                                            *ngIf=\"item.value.includes('ERROR') == false && item.value.includes('WARN') == false && item.value.includes('WARNING') == false\">\n                                                                            <span [innerHTML]=\"item.value\"></span>\n                                                                        </ng-container>\n                                                                    </span>\n                                                                </mark>\n                            \n                                                                <br *ngIf=\"item.label=='<br>' && !col.hidden\">\n                                                            </ng-container>\n                                                            <br *ngIf=\"!col.hidden\">\n                                                            <ng-container *ngFor=\"let key of row.response\">                            \n                                                                <span\n                                                                    *ngIf=\"isCreateTable==false &&  isCustomTable==false && (!sourceformatvalue.includes(key.label)) && key.label!='<br>' && key.label != 'log_key' && key.label != '@version' && key.label != '_type' && key.label != '_score' && key.label != '_index' && selectRow[row.no]==1 && key.value != null\"\n                                                                    [ngClass]=\"key.label == 'message' || key.label == '@timestamp' || key.label == 'time' || key.label == '_score'? '' : 'key-label clickable'\"\n                                                                    (click)=\"copyLabel(key.label+':'+key.value,true)\" style=\"user-select: none;\"><b\n                                                                       class=\"bg-neutral-300 d-bg-neutral-700\">&nbsp;{{key.label}}\n                                                                        : </b>\n                                                                </span>\n                                                                <span\n                                                                    *ngIf=\"isCreateTable==false && isCustomTable==false && (!sourceformatvalue.includes(key.label)) && key.label!='<br>' && key.label != 'log_key' && key.label != '@version' && key.label != '_type' && key.label != '_score' && key.label != '_index' && selectRow[row.no]==1 && similerLogHiglight == false && key.label != 'message' && key.value != null\"\n                                                                    style=\"margin-right: 20px;line-height: 21px;line-break: anywhere;\"\n                                                                    [innerHTML]=\"key.value\">\n                                                                </span>\n                                                                <span\n                                                                    *ngIf=\"isCreateTable==false && isCustomTable==false && (!sourceformatvalue.includes(key.label)) && key.label!='<br>' && key.label != 'log_key' && key.label != '@version' && key.label != '_type' && key.label != '_score' && key.label != '_index' && selectRow[row.no]==1 && similerLogHiglight == true && key.value != similerMessage && key.label != 'message' && key.value != null\"\n                                                                    style=\"margin-right: 20px;line-height: 21px;line-break: anywhere;\"\n                                                                    [innerHTML]=\"key.value\">\n                                                                </span>\n                                                                <mark class=\"markClsassExpand\"\n                                                                    *ngIf=\"similerLogHiglight == true && key.value == similerMessage\">\n                                                                    <span\n                                                                        *ngIf=\"isCreateTable==false && isCustomTable==false && (!sourceformatvalue.includes(key.label)) && key.label!='<br>' && key.label != 'log_key' &&  selectRow[row.no]==1 && key.label != 'message' && key.label != '@version' && key.label != '_type' && key.label != '_score' && key.label != '_index' && key.value != null\"\n                                                                        style=\"margin-right: 20px;line-height: 21px;line-break: anywhere;\"\n                                                                        [innerHTML]=\"key.value\">\n                                                                    </span>\n                                                                </mark>\n                                                                <br *ngIf=\"key.label=='<br>' && !col.hidden\">\n                                                                <span\n                                                                    *ngIf=\"(isCreateTable==true && key.label == col.valueField && key.label!='<br>' && isCustomTable != true && query.includes('|table') == false)\"\n                                                                    class=\"key-label\" [innerHTML]=\"key.value\" style=\"line-height: 0px;\">\n                                                                </span>\n                                                            </ng-container>\n                                                            <ul class=\"ul-menu clickable\" style=\"position: fixed;\">\n                                                                <li (click)=\"copyText($event)\">Search</li>\n                                                                <li (click)=\"createMonitor($event)\">Log Monitor</li>\n                                                                <li [ngClass] = \"userPermission == false ? 'disableLiEle' : ''\"(click)=\"openExtractFieldDialog($event,row)\">Extract Fields</li>\n                                                            </ul>\n                                                        </span>\n                                                        <br *ngIf=\"!col.hidden\">\n                                                        <span class=\"columndata\" *ngIf=\"row[col.valueField] && col.valueField=='Time'\">{{\n                                                            sessionService.convertTimestampIntoFormattedString(sessionService.convertFormattedStringIntoTimestamp(row[col.valueField],\n                                                            'YYYY-MM-DD “T” hh:mm:ss.SSSZ'),'MM/DD/YYYY HH:mm:ss.SSS')\n                                                            }}</span>\n                            \n                                                        <span class=\"columndata\"\n                                                            *ngIf=\"row['nextTime'] == '-' && col.valueField == 'Time Diff' && sorting == 'desc' && isSorting == true\"\n                                                            style=\"margin: auto; display: table; line-break: anywhere;\">{{\n                                                            row['nextTime']}}</span>\n                                                        <span class=\"columndata\"\n                                                            *ngIf=\"row['no'] != row.length && col.valueField == 'Time Diff' && sorting == 'desc' && row['nextTime'] != '-' && isSorting == true\"\n                                                            style=\"margin: auto; display: table; line-break: anywhere;\">{{\n                                                            convertNumberIntoFormat((sessionService.convertFormattedStringIntoTimestamp(row['Time'], 'YYYY-MM-DD “T”\n                                                            hh:mm:ss.SSSZ') - sessionService.convertFormattedStringIntoTimestamp(row['nextTime'],\n                                                            'YYYY-MM-DD “T” hh:mm:ss.SSSZ')))\n                                                            }}</span>\n                                                        <span class=\"columndata\"\n                                                            *ngIf=\"row['no'] == 1 && col.valueField == 'Time Diff' && sorting == 'asc' && isSorting == true\"\n                                                            style=\"margin: auto; display: table; line-break: anywhere;\">{{\n                                                            row['prevTime']}}</span>\n                                                        <span class=\"columndata\"\n                                                            *ngIf=\"row['no'] != 1 && col.valueField == 'Time Diff' && sorting == 'asc' && isSorting == true\"\n                                                            style=\"margin: auto;display: table; line-break: anywhere;\">{{\n                                                            convertNumberIntoFormat((sessionService.convertFormattedStringIntoTimestamp(row['Time'], 'YYYY-MM-DD “T”\n                                                            hh:mm:ss.SSSZ') - sessionService.convertFormattedStringIntoTimestamp(row['prevTime'],\n                                                            'YYYY-MM-DD “T” hh:mm:ss.SSSZ')))\n                                                            }}</span>\n                                                        <span class=\"columndata\" *ngIf=\"col.valueField == 'Elapsed Time' && isSorting == true\"\n                                                            style=\"margin: auto;display: table; line-break: anywhere;\">{{\n                                                            convertNumberIntoFormat(row['elapsedTime'])\n                                                            }}</span>\n                            \n                                                        <span class=\"columndata\"\n                                                            *ngIf=\"col.label != 'Count' && col.label != 'doc_count' && row[col.valueField] && col.valueField !='Time'\">\n                                                            {{ row[col.valueField] }}</span>\n                                                        <span class=\"columndata clickable\" *ngIf=\"col.label == 'Count' && row[col.valueField]\">\n                                                            <ul class=\"ul-docCount btn-icon font-weight-600\">\n                                                                <li style=\"text-align: -webkit-center;\" (click)=\"callDocCount(row)\">{{\n                                                                    row[col.valueField] }}</li>\n                                                            </ul>\n                                                        </span>\n                                                        <button type=\"button\" class=\"btn-icon\">\n                                                            <i *ngIf=\"col.iconField\" class=\"icons8 icons8-menu-vertical\"\n                                                                [matMenuTriggerFor]=\"menulist\" (menuOpened)=\"openMenu(row.response,true)\"\n                                                                pTooltip=\"Open Menu\"></i>\n                                                        </button>\n                            \n                            \n                                                        <mat-menu #menulist=\"matMenu\">\n                                                            <ng-container *ngFor=\"let item of ddrItems\">\n                                                                <button (click)=\"getMenuItem(item.label,row.response,row)\" mat-menu-item>{{\n                                                                    item.label }}</button>\n                                                            </ng-container>\n                                                        </mat-menu>\n                                                    </div>\n                                                    <button type=\"button\" pButton class=\"btn-icon thicon\" icon=\"icons8 icons8-table\" (click)=\"togleTable(rowIndex)\"\n                                                        pTooltip=\"{{ this['isTableExpand'+ rowIndex] == true ? 'Collapse Table' : 'Expand Table'}}\"\n                                                        *ngIf=\"!isCreateTable && col.valueField == 'keyword' && selectRow[row.no]==1\"\n                                                        [pRowToggler]=\"row\"></button>\n                            \n                                                    <button class=\"btn-icon collpseIco\" *ngIf=\"!isCreateTable && col.valueField == 'keyword'\"\n                                                        (click)=\"moreinfo($event,row,rowIndex)\" pTooltip=\"{{ selectRow[row.no]==1 ? 'Collapse' : 'Expand'}}\">\n                                                        <i\n                                                            [ngClass]=\"selectRow[row.no]==1 ? 'icons8 icons8-collapse-arrow right' : 'icons8 icons8-expand-arrow right'\">\n                                                        </i>\n                                                    </button>\n                                                </td>\n                                            </tr>\n                                        </ng-template>\n                                        <ng-template pTemplate=\"rowexpansion\" let-row let-columns=\"columns\" let-rowData>\n                                            <tr class=\"sub-row\">\n                                                <td [attr.colspan]=\"columns.length\">\n                                                    <app-log-details [rowdata]=\"rowData\" (plus_paramsObject)='plus_filter($event)'\n                                                        (minus_paramsObject)='minus_filter($event)' (exist_paramsObject)='exist_filter($event)'\n                                                        (pairs)='copyTextFilter($event)'></app-log-details>\n                                                </td>\n                                            </tr>\n                                        </ng-template>\n                                    </p-table>\n                                    <p-overlayPanel #transMap>\n                                        <ng-template pTemplate>\n                                            Transaction Flowmap will be opened..\n                                        </ng-template>\n                                    </p-overlayPanel>\n                                    <p-overlayPanel #sessionReplay>\n                                        <ng-template pTemplate>\n                                            Session Reply will be opened..\n                                        </ng-template>\n                                    </p-overlayPanel>\n                                    <p-overlayPanel #sessionTiming>\n                                        <ng-template pTemplate>\n                                            Session Timing will be opened..\n                                        </ng-template>\n                                    </p-overlayPanel>\n                            \n                                </div>\n                            </p-tabPanel>\n                            <p-tabPanel header=\"EXCEPTIONS\">\n                                  <app-log-exceptions [sourceformatvalue]=\"sourceformatvalue\" [indexpattern]=\"indexpattern\" [responseformat]=\"responseformat\" [sorting]=\"sorting\" (cancelExceptionReq)=\"cancel_exception_req($event)\" (disableclearsearchbutton)=\"disable_clear_search_button($event)\" (disableCancelButton)=\"disable_Cancel_Button($event)\"\n[switchTab]=\"switchTab\" [exceptionTableLoading]=\"exceptionTableLoading\" [query]=\"query\" [onClickCancel]=\"onClickCancel\"  (hitsvalue_exception)=\"exception_hitsvalue($event)\" (exception_Obj)=\"exception_data($event)\" (showExceptionProgressBar)=\"progressBarException($event)\" (exceptionTableResponse) = \"exceptionTableResponse($event)\" [gte]=\"exceptionGteValue\" [lte]=\"exceptionLteValue\" [onClearQueryException]=\"onClearQueryException\" [querySettingsdata]=\"querySettingsdata\"></app-log-exceptions>\n\n                            </p-tabPanel>\n                         </p-tabView>\n                        </div>\n\n                    </div>\n\n                </div>\n            </div>\n        </div>\n    </div>\n</div>\n<!-- save search dialog -->\n<app-save-dialog #saveSearchData [isDedup] = \"isDedupChecked\"></app-save-dialog>\n<app-commonfilter #commonFilter></app-commonfilter>\n<!-- changes regarding bug-144026( NFDB | Msearch should give error in streamingNFDB)-->\n<div class=\"custom-toast py-8 pl-8 pr-4\" *ngIf=\"isCustomError\">\n    <div class=\"w-100-p p-grid p-align-center p-justify-between\">\n        <div class=\"font-weight-600 p-grid p-align-center\">\n            <i class=\"pi pi-times-circle font-24 clickable\" (click)=\"isCustomError = false\"></i>\n            <span>Node Error</span>\n        </div>\n        <div class=\"btn-section p-col-fixed p-col-nogutter\">\n            <i class=\"pi pi-times clickable\" (click)=\"isCustomError = false\"></i>\n        </div>\n    </div>\n    <div class=\"w-100-p p-grid p-align-center\">\n        <div class=\"p-col  pcol-nogutter\" [ngStyle]=\"Error.length > 38 == true ? {'max-height' :'300px','overflow':'auto'} : {}\">\n            {{Error}}\n        </div>\n        <div class=\"p-col-fixed font-weight-600 p-col-nogutter clickable\" (click)=\"showFullErrorMsg()\" *ngIf=\"isShowMoreBtn == true\">\n            More            \n        </div>\n\n    </div>\n</div>\n\n\n\n\n\n";
    /***/
  },

  /***/
  "./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/no-result-found/no-result-found.component.html":
  /*!*************************************************************************************************************************!*\
    !*** ./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/no-result-found/no-result-found.component.html ***!
    \*************************************************************************************************************************/

  /*! exports provided: default */

  /***/
  function _node_modules_rawLoader_dist_cjsJs_src_app_pages_home_logstab_noResultFound_noResultFoundComponentHtml(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony default export */


    __webpack_exports__["default"] = "<h1>No results found &#9785;</h1>\n<p id=\"msg1\">Unfortunately I could not find any results matching your search. I tried really hard. I looked all over the place and frankly, I just couldn't find anything good. Help me, help you. Here are some ideas:</p>\n<h2>Expand your time range</h2>\n<p id=\"msg2\" >I see you are looking at an index with a date field. It is possible your query does not match anything in the current time range, or that there is no data at all in the currently selected time range.  \nTry with different time range.For future reference you can open the time picker by clicking on the button in the top right corner of your screen.</p>\n<h2>Refine your query</h2>\n<p id=\"msg2\">The search bar at the top uses Log Monitor DataBase support for NFDBCoreQuery String syntax. Let's say we're searching web server logs that have been parsed into a few fields.</p>\n<h3>Examples:</h3>\n<p id=\"msg2\">Find requests that contain the number 200, in any field:</p>\n<input type=\"text\" value=\"200\" disabled />\n<p id=\"msg2\">Or we can search in a specific field. Find 200 in the status field:</p>\n<input type=\"text\" value=\"value:200\" disabled />\n<p id=\"msg2\">Find all status codes between 400-499:</p>\n<input type=\"text\" value=\"status:[400 TO 499]\" disabled />\n<p id=\"msg2\">Find status codes 400-499 with the extension php:</p>\n<input type=\"text\" value=\"status:[400 TO 499] AND extension:PHP\" disabled />\n<p id=\"msg2\">Or HTML</p>\n<input type=\"text\" value=\"status:[400 TO 499] AND (extension:php OR extension:html)\" disabled />\n";
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/antlr/GrammarLexer.js":
  /*!**********************************************************!*\
    !*** ./src/app/pages/home/logstab/antlr/GrammarLexer.js ***!
    \**********************************************************/

  /*! exports provided: default */

  /***/
  function _src_app_pages_home_logstab_antlr_GrammarLexerJs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! antlr4 */
    "./node_modules/antlr4/index.js");
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(antlr4__WEBPACK_IMPORTED_MODULE_0__); // Generated from GrammarLexer.g4 by ANTLR 4.8
    // jshint ignore: start


    var serializedATN = ["\x03\u608B\uA72A\u8133\uB9ED\u417C\u3BE7\u7786\u5964", "\x02Y\u033C\b\x01\x04\x02\t\x02\x04\x03\t\x03\x04", "\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07\t", "\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\x0B\t\x0B\x04", "\f\t\f\x04\r\t\r\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10", "\t\x10\x04\x11\t\x11\x04\x12\t\x12\x04\x13\t\x13", "\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17", "\t\x17\x04\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A", "\x04\x1B\t\x1B\x04\x1C\t\x1C\x04\x1D\t\x1D\x04\x1E", "\t\x1E\x04\x1F\t\x1F\x04 \t \x04!\t!\x04\"\t\"\x04#", "\t#\x04$\t$\x04%\t%\x04&\t&\x04'\t'\x04(\t(\x04)\t)\x04", "*\t*\x04+\t+\x04,\t,\x04-\t-\x04.\t.\x04/\t/\x040\t0\x04", "1\t1\x042\t2\x043\t3\x044\t4\x045\t5\x046\t6\x047\t7\x04", "8\t8\x049\t9\x04:\t:\x04;\t;\x04<\t<\x04=\t=\x04>\t>\x04", "?\t?\x04@\t@\x04A\tA\x04B\tB\x04C\tC\x04D\tD\x04E\tE\x04", "F\tF\x04G\tG\x04H\tH\x04I\tI\x04J\tJ\x04K\tK\x04L\tL\x04", "M\tM\x04N\tN\x04O\tO\x04P\tP\x04Q\tQ\x04R\tR\x04S\tS\x04", "T\tT\x04U\tU\x04V\tV\x04W\tW\x04X\tX\x03\x02\x03\x02", "\x03\x02\x05\x02\xB5\n\x02\x03\x02\x03\x02\x03", "\x03\x06\x03\xBA\n\x03\r\x03\x0E\x03\xBB\x03\x03", "\x03\x03\x03\x03\x03\x03\x03\x03\x05\x03\xC3\n", "\x03\x03\x03\x03\x03\x03\x04\x03\x04\x03\x04\x03", "\x05\x03\x05\x03\x05\x03\x06\x03\x06\x03\x06\x03", "\x06\x03\x06\x03\x06\x03\x06\x03\x06\x05\x06\xD5", "\n\x06\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07", "\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x05\x07", "\u011D\n\x07\x03\b\x03\b\x03\b\x03\b\x03\b\x03\t\x03", "\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03", "\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03", "\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03", "\t\x03\t\x05\t\u0142\n\t\x03\n\x03\n\x03\n\x03\n\x03\x0B", "\x03\x0B\x03\x0B\x03\x0B\x03\x0B\x03\f\x03\f\x03", "\f\x03\f\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\x0E", "\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0F\x03\x0F", "\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x10\x03\x10", "\x03\x10\x03\x10\x03\x10\x03\x10\x03\x11\x03\x11", "\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x12", "\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12", "\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x03\x14", "\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14", "\x03\x15\x03\x15\x03\x15\x03\x15\x03\x15\x03\x15", "\x03\x15\x03\x15\x03\x15\x03\x15\x03\x16\x03\x16", "\x03\x16\x03\x16\x03\x16\x03\x16\x03\x16\x03\x16", "\x03\x16\x03\x17\x03\x17\x03\x17\x03\x17\x03\x17", "\x03\x17\x03\x18\x03\x18\x03\x18\x03\x18\x03\x18", "\x03\x18\x03\x18\x03\x18\x03\x18\x03\x19\x03\x19", "\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19", "\x03\x19\x03\x19\x03\x19\x03\x19\x03\x1A\x03\x1A", "\x03\x1A\x03\x1A\x03\x1A\x03\x1B\x03\x1B\x03\x1B", "\x03\x1B\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C", "\x03\x1C\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1E", "\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E", "\x03\x1E\x03\x1E\x03\x1F\x03\x1F\x03\x1F\x03\x1F", "\x03\x1F\x03\x1F\x03 \x03 \x03 \x03 \x03 \x03 \x03", "!\x03!\x03!\x03!\x03!\x03!\x03\"\x03\"\x03\"\x03\"", "\x03\"\x03#\x03#\x03#\x03#\x03#\x03$\x03$\x03$\x03", "$\x03$\x03$\x03%\x03%\x03%\x03&\x03&\x03&\x03&\x03", "&\x03&\x03&\x03&\x03&\x03'\x03'\x03'\x03'\x03", "'\x03'\x03'\x03'\x03(\x03(\x03(\x03(\x03(\x03", "(\x03(\x03(\x03)\x03)\x03)\x03)\x03)\x03)\x03)\x03", "*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03", "*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03*\x03", "*\x03*\x05*\u0227\n*\x03+\x03+\x03+\x03+\x03+\x03+\x03", "+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x05+\u0238", "\n+\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03", ",\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x03,\x05,\u024C", "\n,\x03-\x03-\x03-\x03-\x03-\x03-\x03-\x03-\x03-\x03", "-\x03-\x03-\x03-\x03-\x05-\u025C\n-\x03.\x03.\x03.\x03", ".\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x03.\x05.\u026A", "\n.\x03/\x03/\x03/\x03/\x03/\x030\x030\x030\x030\x03", "0\x030\x050\u0277\n0\x031\x031\x031\x031\x031\x032\x03", "2\x032\x032\x032\x032\x033\x033\x033\x033\x073\u0288", "\n3\f3\x0E3\u028B\x0B3\x033\x033\x034\x034\x034\x03", "4\x034\x034\x034\x035\x035\x035\x035\x035\x035\x03", "5\x035\x035\x035\x035\x035\x035\x035\x055\u02A4\n5\x03", "6\x036\x036\x036\x037\x037\x037\x037\x037\x038\x03", "8\x038\x038\x038\x038\x038\x038\x038\x039\x039\x03", "9\x039\x039\x039\x039\x039\x039\x059\u02C1\n9\x03:\x03", ":\x03:\x07:\u02C6\n:\f:\x0E:\u02C9\x0B:\x05:\u02CB\n:\x03", ";\x03;\x03;\x07;\u02D0\n;\f;\x0E;\u02D3\x0B;\x03;\x03", ";\x06;\u02D7\n;\r;\x0E;\u02D8\x05;\u02DB\n;\x03<\x06<\u02DE", "\n<\r<\x0E<\u02DF\x03=\x06=\u02E3\n=\r=\x0E=\u02E4\x03>\x03", ">\x03?\x03?\x03@\x03@\x03A\x03A\x03B\x03B\x03C\x03", "C\x03D\x03D\x03E\x03E\x03F\x03F\x03G\x03G\x03H\x03", "H\x03I\x03I\x03J\x03J\x03K\x03K\x03L\x03L\x03M\x03", "M\x03N\x03N\x03O\x03O\x03P\x03P\x03Q\x03Q\x03R\x03", "R\x03R\x03R\x03R\x03S\x03S\x03S\x03S\x03S\x03S\x03", "S\x03S\x03S\x03S\x03S\x03S\x03S\x03S\x03T\x03T\x03", "U\x03U\x03V\x03V\x03V\x03V\x07V\u032A\nV\fV\x0EV\u032D", "\x0BV\x03V\x03V\x03W\x03W\x03W\x07W\u0334\nW\fW\x0E", "W\u0337\x0BW\x05W\u0339\nW\x03X\x03X\x02\x02Y\x03\x03", "\x05\x04\x07\x05\t\x06\x0B\x07\r\b\x0F\t\x11\n\x13", "\x0B\x15\f\x17\r\x19\x0E\x1B\x0F\x1D\x10\x1F\x11", "!\x12#\x13%\x14'\x15)\x16+\x17-\x18/\x191\x1A3\x1B", "5\x1C7\x1D9\x1E;\x1F= ?!A\"C#E$G%I&K'M(O)Q*S+U,W-Y.[/]0_1a", "2c3e4g5i6k7m8o9q:s;u<w=y>{?}@\x7FA\x81B\x83C\x85D\x87E\x89", "F\x8BG\x8DH\x8FI\x91J\x93K\x95L\x97M\x99N\x9BO\x9D", "P\x9FQ\xA1R\xA3S\xA5T\xA7U\xA9V\xABW\xADX\xAFY\x03", "\x02\n\x04\x02\f\ftt\x04\x02\x0B\x0B\"\"\x03\x021", "1\x04\x02>>@@\x03\x023;\x03\x022;\x07\x02002;C\\aac", "|\x05\x02\f\f\x0F\x0F$$\x02\u036D\x02\x03\x03\x02", "\x02\x02\x02\x05\x03\x02\x02\x02\x02\x07\x03\x02", "\x02\x02\x02\t\x03\x02\x02\x02\x02\x0B\x03\x02", "\x02\x02\x02\r\x03\x02\x02\x02\x02\x0F\x03\x02", "\x02\x02\x02\x11\x03\x02\x02\x02\x02\x13\x03\x02", "\x02\x02\x02\x15\x03\x02\x02\x02\x02\x17\x03\x02", "\x02\x02\x02\x19\x03\x02\x02\x02\x02\x1B\x03\x02", "\x02\x02\x02\x1D\x03\x02\x02\x02\x02\x1F\x03\x02", "\x02\x02\x02!\x03\x02\x02\x02\x02#\x03\x02\x02", "\x02\x02%\x03\x02\x02\x02\x02'\x03\x02\x02\x02", "\x02)\x03\x02\x02\x02\x02+\x03\x02\x02\x02\x02", "-\x03\x02\x02\x02\x02/\x03\x02\x02\x02\x021\x03", "\x02\x02\x02\x023\x03\x02\x02\x02\x025\x03\x02", "\x02\x02\x027\x03\x02\x02\x02\x029\x03\x02\x02", "\x02\x02;\x03\x02\x02\x02\x02=\x03\x02\x02\x02", "\x02?\x03\x02\x02\x02\x02A\x03\x02\x02\x02\x02", "C\x03\x02\x02\x02\x02E\x03\x02\x02\x02\x02G\x03", "\x02\x02\x02\x02I\x03\x02\x02\x02\x02K\x03\x02", "\x02\x02\x02M\x03\x02\x02\x02\x02O\x03\x02\x02", "\x02\x02Q\x03\x02\x02\x02\x02S\x03\x02\x02\x02", "\x02U\x03\x02\x02\x02\x02W\x03\x02\x02\x02\x02", "Y\x03\x02\x02\x02\x02[\x03\x02\x02\x02\x02]\x03", "\x02\x02\x02\x02_\x03\x02\x02\x02\x02a\x03\x02", "\x02\x02\x02c\x03\x02\x02\x02\x02e\x03\x02\x02", "\x02\x02g\x03\x02\x02\x02\x02i\x03\x02\x02\x02", "\x02k\x03\x02\x02\x02\x02m\x03\x02\x02\x02\x02", "o\x03\x02\x02\x02\x02q\x03\x02\x02\x02\x02s\x03", "\x02\x02\x02\x02u\x03\x02\x02\x02\x02w\x03\x02", "\x02\x02\x02y\x03\x02\x02\x02\x02{\x03\x02\x02", "\x02\x02}\x03\x02\x02\x02\x02\x7F\x03\x02\x02", "\x02\x02\x81\x03\x02\x02\x02\x02\x83\x03\x02\x02", "\x02\x02\x85\x03\x02\x02\x02\x02\x87\x03\x02\x02", "\x02\x02\x89\x03\x02\x02\x02\x02\x8B\x03\x02\x02", "\x02\x02\x8D\x03\x02\x02\x02\x02\x8F\x03\x02\x02", "\x02\x02\x91\x03\x02\x02\x02\x02\x93\x03\x02\x02", "\x02\x02\x95\x03\x02\x02\x02\x02\x97\x03\x02\x02", "\x02\x02\x99\x03\x02\x02\x02\x02\x9B\x03\x02\x02", "\x02\x02\x9D\x03\x02\x02\x02\x02\x9F\x03\x02\x02", "\x02\x02\xA1\x03\x02\x02\x02\x02\xA3\x03\x02\x02", "\x02\x02\xA5\x03\x02\x02\x02\x02\xA7\x03\x02\x02", "\x02\x02\xA9\x03\x02\x02\x02\x02\xAB\x03\x02\x02", "\x02\x02\xAD\x03\x02\x02\x02\x02\xAF\x03\x02\x02", "\x02\x03\xB4\x03\x02\x02\x02\x05\xC2\x03\x02\x02", "\x02\x07\xC6\x03\x02\x02\x02\t\xC9\x03\x02\x02", "\x02\x0B\xD4\x03\x02\x02\x02\r\u011C\x03\x02\x02", "\x02\x0F\u011E\x03\x02\x02\x02\x11\u0141\x03\x02\x02", "\x02\x13\u0143\x03\x02\x02\x02\x15\u0147\x03\x02\x02", "\x02\x17\u014C\x03\x02\x02\x02\x19\u0150\x03\x02\x02", "\x02\x1B\u0156\x03\x02\x02\x02\x1D\u015B\x03\x02\x02", "\x02\x1F\u0161\x03\x02\x02\x02!\u0167\x03\x02\x02", "\x02#\u016E\x03\x02\x02\x02%\u0175\x03\x02\x02\x02", "'\u017A\x03\x02\x02\x02)\u0181\x03\x02\x02\x02+\u018B", "\x03\x02\x02\x02-\u0194\x03\x02\x02\x02/\u019A\x03", "\x02\x02\x021\u01A3\x03\x02\x02\x023\u01AF\x03\x02", "\x02\x025\u01B4\x03\x02\x02\x027\u01B8\x03\x02\x02", "\x029\u01BE\x03\x02\x02\x02;\u01C2\x03\x02\x02\x02", "=\u01CB\x03\x02\x02\x02?\u01D1\x03\x02\x02\x02A\u01D7", "\x03\x02\x02\x02C\u01DD\x03\x02\x02\x02E\u01E2\x03", "\x02\x02\x02G\u01E7\x03\x02\x02\x02I\u01ED\x03\x02", "\x02\x02K\u01F0\x03\x02\x02\x02M\u01F9\x03\x02\x02", "\x02O\u0201\x03\x02\x02\x02Q\u0209\x03\x02\x02\x02", "S\u0226\x03\x02\x02\x02U\u0237\x03\x02\x02\x02W\u024B", "\x03\x02\x02\x02Y\u025B\x03\x02\x02\x02[\u0269\x03", "\x02\x02\x02]\u026B\x03\x02\x02\x02_\u0276\x03\x02", "\x02\x02a\u0278\x03\x02\x02\x02c\u027D\x03\x02\x02", "\x02e\u0283\x03\x02\x02\x02g\u028E\x03\x02\x02\x02", "i\u02A3\x03\x02\x02\x02k\u02A5\x03\x02\x02\x02m\u02A9", "\x03\x02\x02\x02o\u02AE\x03\x02\x02\x02q\u02C0\x03", "\x02\x02\x02s\u02CA\x03\x02\x02\x02u\u02DA\x03\x02", "\x02\x02w\u02DD\x03\x02\x02\x02y\u02E2\x03\x02\x02", "\x02{\u02E6\x03\x02\x02\x02}\u02E8\x03\x02\x02\x02", "\x7F\u02EA\x03\x02\x02\x02\x81\u02EC\x03\x02\x02\x02", "\x83\u02EE\x03\x02\x02\x02\x85\u02F0\x03\x02\x02\x02", "\x87\u02F2\x03\x02\x02\x02\x89\u02F4\x03\x02\x02\x02", "\x8B\u02F6\x03\x02\x02\x02\x8D\u02F8\x03\x02\x02\x02", "\x8F\u02FA\x03\x02\x02\x02\x91\u02FC\x03\x02\x02\x02", "\x93\u02FE\x03\x02\x02\x02\x95\u0300\x03\x02\x02\x02", "\x97\u0302\x03\x02\x02\x02\x99\u0304\x03\x02\x02\x02", "\x9B\u0306\x03\x02\x02\x02\x9D\u0308\x03\x02\x02\x02", "\x9F\u030A\x03\x02\x02\x02\xA1\u030C\x03\x02\x02\x02", "\xA3\u030E\x03\x02\x02\x02\xA5\u0313\x03\x02\x02\x02", "\xA7\u0321\x03\x02\x02\x02\xA9\u0323\x03\x02\x02\x02", "\xAB\u0325\x03\x02\x02\x02\xAD\u0338\x03\x02\x02\x02", "\xAF\u033A\x03\x02\x02\x02\xB1\xB2\x07\x0F\x02\x02", "\xB2\xB5\x07\f\x02\x02\xB3\xB5\t\x02\x02\x02\xB4", "\xB1\x03\x02\x02\x02\xB4\xB3\x03\x02\x02\x02\xB5", "\xB6\x03\x02\x02\x02\xB6\xB7\b\x02\x02\x02\xB7", "\x04\x03\x02\x02\x02\xB8\xBA\t\x03\x02\x02\xB9", "\xB8\x03\x02\x02\x02\xBA\xBB\x03\x02\x02\x02\xBB", "\xB9\x03\x02\x02\x02\xBB\xBC\x03\x02\x02\x02\xBC", "\xC3\x03\x02\x02\x02\xBD\xBE\x07(\x02\x02\xBE", "\xBF\x07p\x02\x02\xBF\xC0\x07d\x02\x02\xC0\xC1", "\x07u\x02\x02\xC1\xC3\x07r\x02\x02\xC2\xB9\x03", "\x02\x02\x02\xC2\xBD\x03\x02\x02\x02\xC3\xC4\x03", "\x02\x02\x02\xC4\xC5\b\x03\x02\x02\xC5\x06\x03", "\x02\x02\x02\xC6\xC7\x07d\x02\x02\xC7\xC8\x07", "{\x02\x02\xC8\b\x03\x02\x02\x02\xC9\xCA\x07C\x02", "\x02\xCA\xCB\x07U\x02\x02\xCB\n\x03\x02\x02\x02", "\xCC\xCD\x07U\x02\x02\xCD\xCE\x07R\x02\x02\xCE", "\xCF\x07C\x02\x02\xCF\xD5\x07P\x02\x02\xD0\xD1", "\x07u\x02\x02\xD1\xD2\x07r\x02\x02\xD2\xD3\x07", "c\x02\x02\xD3\xD5\x07p\x02\x02\xD4\xCC\x03\x02", "\x02\x02\xD4\xD0\x03\x02\x02\x02\xD5\f\x03\x02", "\x02\x02\xD6\xD7\x07u\x02\x02\xD7\xD8\x07w\x02", "\x02\xD8\u011D\x07o\x02\x02\xD9\xDA\x07o\x02\x02", "\xDA\xDB\x07k\x02\x02\xDB\u011D\x07p\x02\x02\xDC", "\xDD\x07o\x02\x02\xDD\xDE\x07c\x02\x02\xDE\u011D", "\x07z\x02\x02\xDF\xE0\x07c\x02\x02\xE0\xE1\x07", "x\x02\x02\xE1\u011D\x07i\x02\x02\xE2\xE3\x07e\x02", "\x02\xE3\xE4\x07q\x02\x02\xE4\xE5\x07w\x02\x02", "\xE5\xE6\x07p\x02\x02\xE6\u011D\x07v\x02\x02\xE7", "\xE8\x07f\x02\x02\xE8\xE9\x07k\x02\x02\xE9\xEA", "\x07u\x02\x02\xEA\xEB\x07v\x02\x02\xEB\xEC\x07", "k\x02\x02\xEC\xED\x07p\x02\x02\xED\xEE\x07e\x02", "\x02\xEE\xEF\x07v\x02\x02\xEF\xF0\x07a\x02\x02", "\xF0\xF1\x07e\x02\x02\xF1\xF2\x07q\x02\x02\xF2", "\xF3\x07w\x02\x02\xF3\xF4\x07p\x02\x02\xF4\u011D", "\x07v\x02\x02\xF5\xF6\x07u\x02\x02\xF6\xF7\x07", "v\x02\x02\xF7\xF8\x07f\x02\x02\xF8\xF9\x07g\x02", "\x02\xF9\u011D\x07x\x02\x02\xFA\xFB\x07x\x02\x02", "\xFB\xFC\x07c\x02\x02\xFC\u011D\x07t\x02\x02\xFD", "\xFE\x07u\x02\x02\xFE\xFF\x07w\x02\x02\xFF\u0100", "\x07o\x02\x02\u0100\u0101\x07u\x02\x02\u0101\u011D\x07", "s\x02\x02\u0102\u0103\x07g\x02\x02\u0103\u0104\x07c\x02", "\x02\u0104\u0105\x07t\x02\x02\u0105\u0106\x07n\x02\x02", "\u0106\u0107\x07k\x02\x02\u0107\u0108\x07g\x02\x02\u0108", "\u0109\x07u\x02\x02\u0109\u011D\x07v\x02\x02\u010A\u010B", "\x07n\x02\x02\u010B\u010C\x07c\x02\x02\u010C\u010D\x07", "v\x02\x02\u010D\u010E\x07g\x02\x02\u010E\u010F\x07u\x02", "\x02\u010F\u011D\x07v\x02\x02\u0110\u0111\x07o\x02\x02", "\u0111\u0112\x07k\x02\x02\u0112\u0113\x07p\x02\x02\u0113", "\u0114\x07u\x02\x02\u0114\u0115\x07v\x02\x02\u0115\u011D", "\x07t\x02\x02\u0116\u0117\x07o\x02\x02\u0117\u0118\x07", "c\x02\x02\u0118\u0119\x07z\x02\x02\u0119\u011A\x07u\x02", "\x02\u011A\u011B\x07v\x02\x02\u011B\u011D\x07t\x02\x02", "\u011C\xD6\x03\x02\x02\x02\u011C\xD9\x03\x02\x02\x02", "\u011C\xDC\x03\x02\x02\x02\u011C\xDF\x03\x02\x02\x02", "\u011C\xE2\x03\x02\x02\x02\u011C\xE7\x03\x02\x02\x02", "\u011C\xF5\x03\x02\x02\x02\u011C\xFA\x03\x02\x02\x02", "\u011C\xFD\x03\x02\x02\x02\u011C\u0102\x03\x02\x02\x02", "\u011C\u010A\x03\x02\x02\x02\u011C\u0110\x03\x02\x02\x02", "\u011C\u0116\x03\x02\x02\x02\u011D\x0E\x03\x02\x02\x02", "\u011E\u011F\x07r\x02\x02\u011F\u0120\x07g\x02\x02\u0120", "\u0121\x07t\x02\x02\u0121\u0122\x07e\x02\x02\u0122\x10", "\x03\x02\x02\x02\u0123\u0124\x07E\x02\x02\u0124\u0125", "\x07q\x02\x02\u0125\u0126\x07w\x02\x02\u0126\u0127\x07", "p\x02\x02\u0127\u0142\x07v\x02\x02\u0128\u0129\x07C\x02", "\x02\u0129\u012A\x07x\x02\x02\u012A\u012B\x07g\x02\x02", "\u012B\u012C\x07t\x02\x02\u012C\u012D\x07c\x02\x02\u012D", "\u012E\x07i\x02\x02\u012E\u0142\x07g\x02\x02\u012F\u0130", "\x07O\x02\x02\u0130\u0131\x07c\x02\x02\u0131\u0142\x07", "z\x02\x02\u0132\u0133\x07O\x02\x02\u0133\u0134\x07k\x02", "\x02\u0134\u0142\x07p\x02\x02\u0135\u0136\x07U\x02\x02", "\u0136\u0137\x07w\x02\x02\u0137\u0142\x07o\x02\x02\u0138", "\u0139\x07W\x02\x02\u0139\u013A\x07p\x02\x02\u013A\u013B", "\x07k\x02\x02\u013B\u013C\x07s\x02\x02\u013C\u013D\x07", "E\x02\x02\u013D\u013E\x07q\x02\x02\u013E\u013F\x07w\x02", "\x02\u013F\u0140\x07p\x02\x02\u0140\u0142\x07v\x02\x02", "\u0141\u0123\x03\x02\x02\x02\u0141\u0128\x03\x02\x02\x02", "\u0141\u012F\x03\x02\x02\x02\u0141\u0132\x03\x02\x02\x02", "\u0141\u0135\x03\x02\x02\x02\u0141\u0138\x03\x02\x02\x02", "\u0142\x12\x03\x02\x02\x02\u0143\u0144\x07t\x02\x02", "\u0144\u0145\x07g\x02\x02\u0145\u0146\x07z\x02\x02\u0146", "\x14\x03\x02\x02\x02\u0147\u0148\x07g\x02\x02\u0148", "\u0149\x07x\x02\x02\u0149\u014A\x07c\x02\x02\u014A\u014B", "\x07n\x02\x02\u014B\x16\x03\x02\x02\x02\u014C\u014D", "\x07X\x02\x02\u014D\u014E\x07K\x02\x02\u014E\u014F\x07", "U\x02\x02\u014F\x18\x03\x02\x02\x02\u0150\u0151\x07", "f\x02\x02\u0151\u0152\x07g\x02\x02\u0152\u0153\x07f\x02", "\x02\u0153\u0154\x07w\x02\x02\u0154\u0155\x07r\x02\x02", "\u0155\x1A\x03\x02\x02\x02\u0156\u0157\x07l\x02\x02", "\u0157\u0158\x07q\x02\x02\u0158\u0159\x07k\x02\x02\u0159", "\u015A\x07p\x02\x02\u015A\x1C\x03\x02\x02\x02\u015B", "\u015C\x07v\x02\x02\u015C\u015D\x07c\x02\x02\u015D\u015E", "\x07d\x02\x02\u015E\u015F\x07n\x02\x02\u015F\u0160\x07", "g\x02\x02\u0160\x1E\x03\x02\x02\x02\u0161\u0162\x07", "y\x02\x02\u0162\u0163\x07j\x02\x02\u0163\u0164\x07g\x02", "\x02\u0164\u0165\x07t\x02\x02\u0165\u0166\x07g\x02\x02", "\u0166 \x03\x02\x02\x02\u0167\u0168\x07n\x02\x02\u0168", "\u0169\x07q\x02\x02\u0169\u016A\x07q\x02\x02\u016A\u016B", "\x07m\x02\x02\u016B\u016C\x07w\x02\x02\u016C\u016D\x07", "r\x02\x02\u016D\"\x03\x02\x02\x02\u016E\u016F\x07c\x02", "\x02\u016F\u0170\x07r\x02\x02\u0170\u0171\x07r\x02\x02", "\u0171\u0172\x07g\x02\x02\u0172\u0173\x07p\x02\x02\u0173", "\u0174\x07f\x02\x02\u0174$\x03\x02\x02\x02\u0175\u0176", "\x07p\x02\x02\u0176\u0177\x07q\x02\x02\u0177\u0178\x07", "o\x02\x02\u0178\u0179\x07x\x02\x02\u0179&\x03\x02\x02", "\x02\u017A\u017B\x07o\x02\x02\u017B\u017C\x07c\x02\x02", "\u017C\u017D\x07m\x02\x02\u017D\u017E\x07g\x02\x02\u017E", "\u017F\x07o\x02\x02\u017F\u0180\x07x\x02\x02\u0180(\x03", "\x02\x02\x02\u0181\u0182\x07o\x02\x02\u0182\u0183\x07", "x\x02\x02\u0183\u0184\x07e\x02\x02\u0184\u0185\x07q\x02", "\x02\u0185\u0186\x07o\x02\x02\u0186\u0187\x07d\x02\x02", "\u0187\u0188\x07k\x02\x02\u0188\u0189\x07p\x02\x02\u0189", "\u018A\x07g\x02\x02\u018A*\x03\x02\x02\x02\u018B\u018C", "\x07o\x02\x02\u018C\u018D\x07x\x02\x02\u018D\u018E\x07", "g\x02\x02\u018E\u018F\x07z\x02\x02\u018F\u0190\x07r\x02", "\x02\u0190\u0191\x07c\x02\x02\u0191\u0192\x07p\x02\x02", "\u0192\u0193\x07f\x02\x02\u0193,\x03\x02\x02\x02\u0194", "\u0195\x07u\x02\x02\u0195\u0196\x07v\x02\x02\u0196\u0197", "\x07c\x02\x02\u0197\u0198\x07v\x02\x02\u0198\u0199\x07", "u\x02\x02\u0199.\x03\x02\x02\x02\u019A\u019B\x07f\x02", "\x02\u019B\u019C\x07q\x02\x02\u019C\u019D\x07e\x02\x02", "\u019D\u019E\x07u\x02\x02\u019E\u019F\x07v\x02\x02\u019F", "\u01A0\x07c\x02\x02\u01A0\u01A1\x07v\x02\x02\u01A1\u01A2", "\x07u\x02\x02\u01A20\x03\x02\x02\x02\u01A3\u01A4\x07", "u\x02\x02\u01A4\u01A5\x07v\x02\x02\u01A5\u01A6\x07t\x02", "\x02\u01A6\u01A7\x07g\x02\x02\u01A7\u01A8\x07c\x02\x02", "\u01A8\u01A9\x07o\x02\x02\u01A9\u01AA\x07u\x02\x02\u01AA", "\u01AB\x07v\x02\x02\u01AB\u01AC\x07c\x02\x02\u01AC\u01AD", "\x07v\x02\x02\u01AD\u01AE\x07u\x02\x02\u01AE2\x03\x02", "\x02\x02\u01AF\u01B0\x07u\x02\x02\u01B0\u01B1\x07q\x02", "\x02\u01B1\u01B2\x07t\x02\x02\u01B2\u01B3\x07v\x02\x02", "\u01B34\x03\x02\x02\x02\u01B4\u01B5\x07c\x02\x02\u01B5", "\u01B6\x07n\x02\x02\u01B6\u01B7\x07n\x02\x02\u01B76\x03", "\x02\x02\x02\u01B8\u01B9\x07o\x02\x02\u01B9\u01BA\x07", "g\x02\x02\u01BA\u01BB\x07t\x02\x02\u01BB\u01BC\x07i\x02", "\x02\u01BC\u01BD\x07g\x02\x02\u01BD8\x03\x02\x02\x02", "\u01BE\u01BF\x07v\x02\x02\u01BF\u01C0\x07q\x02\x02\u01C0", "\u01C1\x07r\x02\x02\u01C1:\x03\x02\x02\x02\u01C2\u01C3", "\x07h\x02\x02\u01C3\u01C4\x07g\x02\x02\u01C4\u01C5\x07", "v\x02\x02\u01C5\u01C6\x07e\x02\x02\u01C6\u01C7\x07j\x02", "\x02\u01C7\u01C8\x07n\x02\x02\u01C8\u01C9\x07q\x02\x02", "\u01C9\u01CA\x07i\x02\x02\u01CA<\x03\x02\x02\x02\u01CB", "\u01CC\x07k\x02\x02\u01CC\u01CD\x07p\x02\x02\u01CD\u01CE", "\x07f\x02\x02\u01CE\u01CF\x07g\x02\x02\u01CF\u01D0\x07", "z\x02\x02\u01D0>\x03\x02\x02\x02\u01D1\u01D2\x07n\x02", "\x02\u01D2\u01D3\x07k\x02\x02\u01D3\u01D4\x07o\x02\x02", "\u01D4\u01D5\x07k\x02\x02\u01D5\u01D6\x07v\x02\x02\u01D6", "@\x03\x02\x02\x02\u01D7\u01D8\x07h\x02\x02\u01D8\u01D9", "\x07k\x02\x02\u01D9\u01DA\x07t\x02\x02\u01DA\u01DB\x07", "u\x02\x02\u01DB\u01DC\x07v\x02\x02\u01DCB\x03\x02\x02", "\x02\u01DD\u01DE\x07n\x02\x02\u01DE\u01DF\x07c\x02\x02", "\u01DF\u01E0\x07u\x02\x02\u01E0\u01E1\x07v\x02\x02\u01E1", "D\x03\x02\x02\x02\u01E2\u01E3\x07n\x02\x02\u01E3\u01E4", "\x07g\x02\x02\u01E4\u01E5\x07h\x02\x02\u01E5\u01E6\x07", "v\x02\x02\u01E6F\x03\x02\x02\x02\u01E7\u01E8\x07k\x02", "\x02\u01E8\u01E9\x07p\x02\x02\u01E9\u01EA\x07p\x02\x02", "\u01EA\u01EB\x07g\x02\x02\u01EB\u01EC\x07t\x02\x02\u01EC", "H\x03\x02\x02\x02\u01ED\u01EE\x07q\x02\x02\u01EE\u01EF", "\x07p\x02\x02\u01EFJ\x03\x02\x02\x02\u01F0\u01F1\x07", "q\x02\x02\u01F1\u01F2\x07x\x02\x02\u01F2\u01F3\x07g\x02", "\x02\u01F3\u01F4\x07t\x02\x02\u01F4\u01F5\x07t\x02\x02", "\u01F5\u01F6\x07k\x02\x02\u01F6\u01F7\x07f\x02\x02\u01F7", "\u01F8\x07g\x02\x02\u01F8L\x03\x02\x02\x02\u01F9\u01FA", "\x07g\x02\x02\u01FA\u01FB\x07z\x02\x02\u01FB\u01FC\x07", "e\x02\x02\u01FC\u01FD\x07n\x02\x02\u01FD\u01FE\x07w\x02", "\x02\u01FE\u01FF\x07f\x02\x02\u01FF\u0200\x07g\x02\x02", "\u0200N\x03\x02\x02\x02\u0201\u0202\x07k\x02\x02\u0202", "\u0203\x07p\x02\x02\u0203\u0204\x07e\x02\x02\u0204\u0205", "\x07n\x02\x02\u0205\u0206\x07w\x02\x02\u0206\u0207\x07", "f\x02\x02\u0207\u0208\x07g\x02\x02\u0208P\x03\x02\x02", "\x02\u0209\u020A\x07t\x02\x02\u020A\u020B\x07c\x02\x02", "\u020B\u020C\x07p\x02\x02\u020C\u020D\x07f\x02\x02\u020D", "\u020E\x07q\x02\x02\u020E\u020F\x07o\x02\x02\u020FR\x03", "\x02\x02\x02\u0210\u0211\x07c\x02\x02\u0211\u0212\x07", "d\x02\x02\u0212\u0227\x07u\x02\x02\u0213\u0214\x07u\x02", "\x02\u0214\u0215\x07s\x02\x02\u0215\u0216\x07t\x02\x02", "\u0216\u0227\x07v\x02\x02\u0217\u0218\x07h\x02\x02\u0218", "\u0219\x07n\x02\x02\u0219\u021A\x07q\x02\x02\u021A\u021B", "\x07q\x02\x02\u021B\u0227\x07t\x02\x02\u021C\u021D\x07", "e\x02\x02\u021D\u021E\x07g\x02\x02\u021E\u021F\x07k\x02", "\x02\u021F\u0220\x07n\x02\x02\u0220\u0221\x07k\x02\x02", "\u0221\u0222\x07p\x02\x02\u0222\u0227\x07i\x02\x02\u0223", "\u0224\x07n\x02\x02\u0224\u0225\x07g\x02\x02\u0225\u0227", "\x07p\x02\x02\u0226\u0210\x03\x02\x02\x02\u0226\u0213", "\x03\x02\x02\x02\u0226\u0217\x03\x02\x02\x02\u0226\u021C", "\x03\x02\x02\x02\u0226\u0223\x03\x02\x02\x02\u0227T", "\x03\x02\x02\x02\u0228\u0229\x07r\x02\x02\u0229\u022A", "\x07q\x02\x02\u022A\u0238\x07y\x02\x02\u022B\u022C\x07", "t\x02\x02\u022C\u022D\x07q\x02\x02\u022D\u022E\x07w\x02", "\x02\u022E\u022F\x07p\x02\x02\u022F\u0238\x07f\x02\x02", "\u0230\u0231\x07k\x02\x02\u0231\u0232\x07p\x02\x02\u0232", "\u0233\x07f\x02\x02\u0233\u0234\x07g\x02\x02\u0234\u0235", "\x07z\x02\x02\u0235\u0236\x07q\x02\x02\u0236\u0238\x07", "h\x02\x02\u0237\u0228\x03\x02\x02\x02\u0237\u022B\x03", "\x02\x02\x02\u0237\u0230\x03\x02\x02\x02\u0238V\x03", "\x02\x02\x02\u0239\u023A\x07U\x02\x02\u023A\u023B\x07", "V\x02\x02\u023B\u023C\x07C\x02\x02\u023C\u023D\x07T\x02", "\x02\u023D\u023E\x07V\x02\x02\u023E\u023F\x07V\x02\x02", "\u023F\u0240\x07K\x02\x02\u0240\u0241\x07O\x02\x02\u0241", "\u024C\x07G\x02\x02\u0242\u0243\x07u\x02\x02\u0243\u0244", "\x07v\x02\x02\u0244\u0245\x07c\x02\x02\u0245\u0246\x07", "t\x02\x02\u0246\u0247\x07v\x02\x02\u0247\u0248\x07v\x02", "\x02\u0248\u0249\x07k\x02\x02\u0249\u024A\x07o\x02\x02", "\u024A\u024C\x07g\x02\x02\u024B\u0239\x03\x02\x02\x02", "\u024B\u0242\x03\x02\x02\x02\u024CX\x03\x02\x02\x02", "\u024D\u024E\x07G\x02\x02\u024E\u024F\x07P\x02\x02\u024F", "\u0250\x07F\x02\x02\u0250\u0251\x07V\x02\x02\u0251\u0252", "\x07K\x02\x02\u0252\u0253\x07O\x02\x02\u0253\u025C\x07", "G\x02\x02\u0254\u0255\x07g\x02\x02\u0255\u0256\x07p\x02", "\x02\u0256\u0257\x07f\x02\x02\u0257\u0258\x07v\x02\x02", "\u0258\u0259\x07k\x02\x02\u0259\u025A\x07o\x02\x02\u025A", "\u025C\x07g\x02\x02\u025B\u024D\x03\x02\x02\x02\u025B", "\u0254\x03\x02\x02\x02\u025CZ\x03\x02\x02\x02\u025D", "\u025E\x07Q\x02\x02\u025E\u025F\x07W\x02\x02\u025F\u0260", "\x07V\x02\x02\u0260\u0261\x07R\x02\x02\u0261\u0262\x07", "W\x02\x02\u0262\u026A\x07V\x02\x02\u0263\u0264\x07q\x02", "\x02\u0264\u0265\x07w\x02\x02\u0265\u0266\x07v\x02\x02", "\u0266\u0267\x07r\x02\x02\u0267\u0268\x07w\x02\x02\u0268", "\u026A\x07v\x02\x02\u0269\u025D\x03\x02\x02\x02\u0269", "\u0263\x03\x02\x02\x02\u026A\\\x03\x02\x02\x02\u026B", "\u026C\x07g\x02\x02\u026C\u026D\x07z\x02\x02\u026D\u026E", "\x07g\x02\x02\u026E\u026F\x07e\x02\x02\u026F^\x03\x02", "\x02\x02\u0270\u0271\x07e\x02\x02\u0271\u0272\x07c\x02", "\x02\u0272\u0273\x07u\x02\x02\u0273\u0277\x07g\x02\x02", "\u0274\u0275\x07k\x02\x02\u0275\u0277\x07h\x02\x02\u0276", "\u0270\x03\x02\x02\x02\u0276\u0274\x03\x02\x02\x02\u0277", "`\x03\x02\x02\x02\u0278\u0279\x07v\x02\x02\u0279\u027A", "\x07t\x02\x02\u027A\u027B\x07w\x02\x02\u027B\u027C\x07", "g\x02\x02\u027Cb\x03\x02\x02\x02\u027D\u027E\x07h\x02", "\x02\u027E\u027F\x07c\x02\x02\u027F\u0280\x07n\x02\x02", "\u0280\u0281\x07u\x02\x02\u0281\u0282\x07g\x02\x02\u0282", "d\x03\x02\x02\x02\u0283\u0289\x071\x02\x02\u0284\u0288", "\n\x04\x02\x02\u0285\u0286\x07^\x02\x02\u0286\u0288\x07", "1\x02\x02\u0287\u0284\x03\x02\x02\x02\u0287\u0285\x03", "\x02\x02\x02\u0288\u028B\x03\x02\x02\x02\u0289\u0287\x03", "\x02\x02\x02\u0289\u028A\x03\x02\x02\x02\u028A\u028C\x03", "\x02\x02\x02\u028B\u0289\x03\x02\x02\x02\u028C\u028D\x07", "1\x02\x02\u028Df\x03\x02\x02\x02\u028E\u028F\x07u\x02", "\x02\u028F\u0290\x07w\x02\x02\u0290\u0291\x07d\x02\x02", "\u0291\u0292\x07u\x02\x02\u0292\u0293\x07v\x02\x02\u0293", "\u0294\x07t\x02\x02\u0294h\x03\x02\x02\x02\u0295\u0296", "\x07\"\x02\x02\u0296\u0297\x07C\x02\x02\u0297\u0298\x07", "P\x02\x02\u0298\u0299\x07F\x02\x02\u0299\u02A4\x07\"\x02", "\x02\u029A\u029B\x07\"\x02\x02\u029B\u029C\x07Q\x02\x02", "\u029C\u029D\x07T\x02\x02\u029D\u02A4\x07\"\x02\x02\u029E", "\u029F\x07\"\x02\x02\u029F\u02A0\x07P\x02\x02\u02A0\u02A1", "\x07Q\x02\x02\u02A1\u02A2\x07V\x02\x02\u02A2\u02A4\x07", "\"\x02\x02\u02A3\u0295\x03\x02\x02\x02\u02A3\u029A\x03", "\x02\x02\x02\u02A3\u029E\x03\x02\x02\x02\u02A4j\x03", "\x02\x02\x02\u02A5\u02A6\x07c\x02\x02\u02A6\u02A7\x07", "u\x02\x02\u02A7\u02A8\x07e\x02\x02\u02A8l\x03\x02\x02", "\x02\u02A9\u02AA\x07f\x02\x02\u02AA\u02AB\x07g\x02\x02", "\u02AB\u02AC\x07u\x02\x02\u02AC\u02AD\x07e\x02\x02\u02AD", "n\x03\x02\x02\x02\u02AE\u02AF\x07o\x02\x02\u02AF\u02B0", "\x07c\x02\x02\u02B0\u02B1\x07z\x02\x02\u02B1\u02B2\x07", "o\x02\x02\u02B2\u02B3\x07c\x02\x02\u02B3\u02B4\x07v\x02", "\x02\u02B4\u02B5\x07e\x02\x02\u02B5\u02B6\x07j\x02\x02", "\u02B6p\x03\x02\x02\x02\u02B7\u02C1\t\x05\x02\x02\u02B8", "\u02B9\x07@\x02\x02\u02B9\u02C1\x07?\x02\x02\u02BA\u02BB", "\x07>\x02\x02\u02BB\u02C1\x07?\x02\x02\u02BC\u02BD\x07", "?\x02\x02\u02BD\u02C1\x07?\x02\x02\u02BE\u02BF\x07#\x02", "\x02\u02BF\u02C1\x07?\x02\x02\u02C0\u02B7\x03\x02\x02", "\x02\u02C0\u02B8\x03\x02\x02\x02\u02C0\u02BA\x03\x02\x02", "\x02\u02C0\u02BC\x03\x02\x02\x02\u02C0\u02BE\x03\x02\x02", "\x02\u02C1r\x03\x02\x02\x02\u02C2\u02CB\x072\x02\x02", "\u02C3\u02C7\t\x06\x02\x02\u02C4\u02C6\t\x07\x02\x02\u02C5", "\u02C4\x03\x02\x02\x02\u02C6\u02C9\x03\x02\x02\x02\u02C7", "\u02C5\x03\x02\x02\x02\u02C7\u02C8\x03\x02\x02\x02\u02C8", "\u02CB\x03\x02\x02\x02\u02C9\u02C7\x03\x02\x02\x02\u02CA", "\u02C2\x03\x02\x02\x02\u02CA\u02C3\x03\x02\x02\x02\u02CB", "t\x03\x02\x02\x02\u02CC\u02DB\x072\x02\x02\u02CD\u02D1", "\t\x06\x02\x02\u02CE\u02D0\t\x07\x02\x02\u02CF\u02CE\x03", "\x02\x02\x02\u02D0\u02D3\x03\x02\x02\x02\u02D1\u02CF\x03", "\x02\x02\x02\u02D1\u02D2\x03\x02\x02\x02\u02D2\u02D4\x03", "\x02\x02\x02\u02D3\u02D1\x03\x02\x02\x02\u02D4\u02D6\x07", "0\x02\x02\u02D5\u02D7\t\x07\x02\x02\u02D6\u02D5\x03\x02", "\x02\x02\u02D7\u02D8\x03\x02\x02\x02\u02D8\u02D6\x03\x02", "\x02\x02\u02D8\u02D9\x03\x02\x02\x02\u02D9\u02DB\x03\x02", "\x02\x02\u02DA\u02CC\x03\x02\x02\x02\u02DA\u02CD\x03\x02", "\x02\x02\u02DBv\x03\x02\x02\x02\u02DC\u02DE\t\b\x02\x02", "\u02DD\u02DC\x03\x02\x02\x02\u02DE\u02DF\x03\x02\x02\x02", "\u02DF\u02DD\x03\x02\x02\x02\u02DF\u02E0\x03\x02\x02\x02", "\u02E0x\x03\x02\x02\x02\u02E1\u02E3\t\x07\x02\x02\u02E2", "\u02E1\x03\x02\x02\x02\u02E3\u02E4\x03\x02\x02\x02\u02E4", "\u02E2\x03\x02\x02\x02\u02E4\u02E5\x03\x02\x02\x02\u02E5", "z\x03\x02\x02\x02\u02E6\u02E7\x07-\x02\x02\u02E7|\x03", "\x02\x02\x02\u02E8\u02E9\x07/\x02\x02\u02E9~\x03\x02", "\x02\x02\u02EA\u02EB\x07,\x02\x02\u02EB\x80\x03\x02", "\x02\x02\u02EC\u02ED\x071\x02\x02\u02ED\x82\x03\x02", "\x02\x02\u02EE\u02EF\x07?\x02\x02\u02EF\x84\x03\x02", "\x02\x02\u02F0\u02F1\x07*\x02\x02\u02F1\x86\x03\x02", "\x02\x02\u02F2\u02F3\x07+\x02\x02\u02F3\x88\x03\x02", "\x02\x02\u02F4\u02F5\x07]\x02\x02\u02F5\x8A\x03\x02", "\x02\x02\u02F6\u02F7\x07_\x02\x02\u02F7\x8C\x03\x02", "\x02\x02\u02F8\u02F9\x07}\x02\x02\u02F9\x8E\x03\x02", "\x02\x02\u02FA\u02FB\x07\x7F\x02\x02\u02FB\x90\x03\x02", "\x02\x02\u02FC\u02FD\x07<\x02\x02\u02FD\x92\x03\x02", "\x02\x02\u02FE\u02FF\x07$\x02\x02\u02FF\x94\x03\x02", "\x02\x02\u0300\u0301\x070\x02\x02\u0301\x96\x03\x02", "\x02\x02\u0302\u0303\x07B\x02\x02\u0303\x98\x03\x02", "\x02\x02\u0304\u0305\x07A\x02\x02\u0305\x9A\x03\x02", "\x02\x02\u0306\u0307\x07,\x02\x02\u0307\x9C\x03\x02", "\x02\x02\u0308\u0309\x07(\x02\x02\u0309\x9E\x03\x02", "\x02\x02\u030A\u030B\x07&\x02\x02\u030B\xA0\x03\x02", "\x02\x02\u030C\u030D\x07`\x02\x02\u030D\xA2\x03\x02", "\x02\x02\u030E\u030F\x07p\x02\x02\u030F\u0310\x07w\x02", "\x02\u0310\u0311\x07n\x02\x02\u0311\u0312\x07n\x02\x02", "\u0312\xA4\x03\x02\x02\x02\u0313\u0314\x07]\x02\x02", "\u0314\u0315\x07C\x02\x02\u0315\u0316\x07/\x02\x02\u0316", "\u0317\x07\\\x02\x02\u0317\u0318\x07c\x02\x02\u0318\u0319", "\x07/\x02\x02\u0319\u031A\x07|\x02\x02\u031A\u031B\x07", "2\x02\x02\u031B\u031C\x07/\x02\x02\u031C\u031D\x07;\x02", "\x02\u031D\u031E\x07a\x02\x02\u031E\u031F\x07_\x02\x02", "\u031F\u0320\x07-\x02\x02\u0320\xA6\x03\x02\x02\x02", "\u0321\u0322\x07~\x02\x02\u0322\xA8\x03\x02\x02\x02", "\u0323\u0324\x07.\x02\x02\u0324\xAA\x03\x02\x02\x02", "\u0325\u032B\x07$\x02\x02\u0326\u0327\x07$\x02\x02\u0327", "\u032A\x07$\x02\x02\u0328\u032A\n\t\x02\x02\u0329\u0326\x03", "\x02\x02\x02\u0329\u0328\x03\x02\x02\x02\u032A\u032D\x03", "\x02\x02\x02\u032B\u0329\x03\x02\x02\x02\u032B\u032C\x03", "\x02\x02\x02\u032C\u032E\x03\x02\x02\x02\u032D\u032B\x03", "\x02\x02\x02\u032E\u032F\x07$\x02\x02\u032F\xAC\x03", "\x02\x02\x02\u0330\u0339\x072\x02\x02\u0331\u0335\x04", "3;\x02\u0332\u0334\x042;\x02\u0333\u0332\x03\x02\x02\x02", "\u0334\u0337\x03\x02\x02\x02\u0335\u0333\x03\x02\x02\x02", "\u0335\u0336\x03\x02\x02\x02\u0336\u0339\x03\x02\x02\x02", "\u0337\u0335\x03\x02\x02\x02\u0338\u0330\x03\x02\x02\x02", "\u0338\u0331\x03\x02\x02\x02\u0339\xAE\x03\x02\x02\x02", "\u033A\u033B\x0B\x02\x02\x02\u033B\xB0\x03\x02\x02\x02", "\x1E\x02\xB4\xBB\xC2\xD4\u011C\u0141\u0226\u0237\u024B\u025B", "\u0269\u0276\u0287\u0289\u02A3\u02C0\u02C7\u02CA\u02D1\u02D8\u02DA\u02DF", "\u02E4\u0329\u032B\u0335\u0338\x03\b\x02\x02"].join("");
    var atn = new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.atn.ATNDeserializer().deserialize(serializedATN);
    var decisionsToDFA = atn.decisionToState.map(function (ds, index) {
      return new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.dfa.DFA(ds, index);
    });

    function GrammarLexer(input) {
      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.Lexer.call(this, input);
      this._interp = new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.atn.LexerATNSimulator(this, atn, decisionsToDFA, new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.PredictionContextCache());
      return this;
    }

    GrammarLexer.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.Lexer.prototype);
    GrammarLexer.prototype.constructor = GrammarLexer;
    Object.defineProperty(GrammarLexer.prototype, "atn", {
      get: function get() {
        return atn;
      }
    });
    GrammarLexer.EOF = antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.Token.EOF;
    GrammarLexer.NEWLINE = 1;
    GrammarLexer.WS = 2;
    GrammarLexer.BY = 3;
    GrammarLexer.AS = 4;
    GrammarLexer.SPAN = 5;
    GrammarLexer.STATSFUNCS = 6;
    GrammarLexer.STATSTWOPARAMFUNCS = 7;
    GrammarLexer.METRIC_METHOD = 8;
    GrammarLexer.REX = 9;
    GrammarLexer.EVAL = 10;
    GrammarLexer.VIS = 11;
    GrammarLexer.DEDUP = 12;
    GrammarLexer.JOIN = 13;
    GrammarLexer.TABLE = 14;
    GrammarLexer.WHERE = 15;
    GrammarLexer.LOOKUP = 16;
    GrammarLexer.APPEND = 17;
    GrammarLexer.NOMV = 18;
    GrammarLexer.MAKEMV = 19;
    GrammarLexer.MVCOMBINE = 20;
    GrammarLexer.MVEXPAND = 21;
    GrammarLexer.STATS = 22;
    GrammarLexer.DOCSTATS = 23;
    GrammarLexer.STREAMSTATS = 24;
    GrammarLexer.SORT = 25;
    GrammarLexer.ALL = 26;
    GrammarLexer.MERGE = 27;
    GrammarLexer.TOP = 28;
    GrammarLexer.FETCHLOG = 29;
    GrammarLexer.INDEX = 30;
    GrammarLexer.LIMIT = 31;
    GrammarLexer.FIRST = 32;
    GrammarLexer.LAST = 33;
    GrammarLexer.LEFT = 34;
    GrammarLexer.INNER = 35;
    GrammarLexer.ON = 36;
    GrammarLexer.OVERRIDE = 37;
    GrammarLexer.EXCLUDE = 38;
    GrammarLexer.INCLUDE = 39;
    GrammarLexer.NOPARAMEVAL = 40;
    GrammarLexer.ONEPARAMEVAL = 41;
    GrammarLexer.TWOPARAMEVAL = 42;
    GrammarLexer.STARTTIME = 43;
    GrammarLexer.ENDTIME = 44;
    GrammarLexer.OUTPUT = 45;
    GrammarLexer.EXEC = 46;
    GrammarLexer.CASE = 47;
    GrammarLexer.TRUE = 48;
    GrammarLexer.FALSE = 49;
    GrammarLexer.REGEX_STR = 50;
    GrammarLexer.SUBSTRING = 51;
    GrammarLexer.LOGICAL_OP = 52;
    GrammarLexer.ASC = 53;
    GrammarLexer.DESC = 54;
    GrammarLexer.MAXMATCH = 55;
    GrammarLexer.CONDITIONS = 56;
    GrammarLexer.INTLIT = 57;
    GrammarLexer.DECLIT = 58;
    GrammarLexer.STRLIT = 59;
    GrammarLexer.NUMBERS = 60;
    GrammarLexer.PLUS = 61;
    GrammarLexer.MINUS = 62;
    GrammarLexer.ASTERISK = 63;
    GrammarLexer.DIVISION = 64;
    GrammarLexer.ASSIGN = 65;
    GrammarLexer.LPAREN = 66;
    GrammarLexer.RPAREN = 67;
    GrammarLexer.LBRACE = 68;
    GrammarLexer.RBRACE = 69;
    GrammarLexer.LMIDDLE = 70;
    GrammarLexer.RMIDDLE = 71;
    GrammarLexer.COLON = 72;
    GrammarLexer.DOUBLE_QUOTE = 73;
    GrammarLexer.DOT = 74;
    GrammarLexer.ATTHERATE = 75;
    GrammarLexer.QUESTIONMARK = 76;
    GrammarLexer.STAR = 77;
    GrammarLexer.AND = 78;
    GrammarLexer.DOLLAR = 79;
    GrammarLexer.CAP = 80;
    GrammarLexer.NULL = 81;
    GrammarLexer.ID = 82;
    GrammarLexer.PIPE = 83;
    GrammarLexer.COMMA = 84;
    GrammarLexer.EXP = 85;
    GrammarLexer.UNSIGNED_INT = 86;
    GrammarLexer.ErrorCharacter = 87;
    GrammarLexer.prototype.channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"];
    GrammarLexer.prototype.modeNames = ["DEFAULT_MODE"];
    GrammarLexer.prototype.literalNames = [null, null, null, "'by'", "'AS'", null, null, null, null, "'rex'", "'eval'", "'VIS'", "'dedup'", "'join'", "'table'", "'where'", "'lookup'", "'append'", "'nomv'", "'makemv'", "'mvcombine'", "'mvexpand'", "'stats'", "'docstats'", "'streamstats'", "'sort'", "'all'", "'merge'", "'top'", "'fetchlog'", "'index'", "'limit'", "'first'", "'last'", "'left'", "'inner'", "'on'", "'override'", "'exclude'", "'include'", "'random'", null, null, null, null, null, "'exec'", null, "'true'", "'false'", null, "'substr'", null, "'asc'", "'desc'", "'maxmatch'", null, null, null, null, null, "'+'", "'-'", null, "'/'", "'='", "'('", "')'", "'['", "']'", "'{'", "'}'", "':'", "'\"'", "'.'", "'@'", "'?'", null, "'&'", "'$'", "'^'", "'null'", "'[A-Za-z0-9_]+'", "'|'", "','"];
    GrammarLexer.prototype.symbolicNames = [null, "NEWLINE", "WS", "BY", "AS", "SPAN", "STATSFUNCS", "STATSTWOPARAMFUNCS", "METRIC_METHOD", "REX", "EVAL", "VIS", "DEDUP", "JOIN", "TABLE", "WHERE", "LOOKUP", "APPEND", "NOMV", "MAKEMV", "MVCOMBINE", "MVEXPAND", "STATS", "DOCSTATS", "STREAMSTATS", "SORT", "ALL", "MERGE", "TOP", "FETCHLOG", "INDEX", "LIMIT", "FIRST", "LAST", "LEFT", "INNER", "ON", "OVERRIDE", "EXCLUDE", "INCLUDE", "NOPARAMEVAL", "ONEPARAMEVAL", "TWOPARAMEVAL", "STARTTIME", "ENDTIME", "OUTPUT", "EXEC", "CASE", "TRUE", "FALSE", "REGEX_STR", "SUBSTRING", "LOGICAL_OP", "ASC", "DESC", "MAXMATCH", "CONDITIONS", "INTLIT", "DECLIT", "STRLIT", "NUMBERS", "PLUS", "MINUS", "ASTERISK", "DIVISION", "ASSIGN", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LMIDDLE", "RMIDDLE", "COLON", "DOUBLE_QUOTE", "DOT", "ATTHERATE", "QUESTIONMARK", "STAR", "AND", "DOLLAR", "CAP", "NULL", "ID", "PIPE", "COMMA", "EXP", "UNSIGNED_INT", "ErrorCharacter"];
    GrammarLexer.prototype.ruleNames = ["NEWLINE", "WS", "BY", "AS", "SPAN", "STATSFUNCS", "STATSTWOPARAMFUNCS", "METRIC_METHOD", "REX", "EVAL", "VIS", "DEDUP", "JOIN", "TABLE", "WHERE", "LOOKUP", "APPEND", "NOMV", "MAKEMV", "MVCOMBINE", "MVEXPAND", "STATS", "DOCSTATS", "STREAMSTATS", "SORT", "ALL", "MERGE", "TOP", "FETCHLOG", "INDEX", "LIMIT", "FIRST", "LAST", "LEFT", "INNER", "ON", "OVERRIDE", "EXCLUDE", "INCLUDE", "NOPARAMEVAL", "ONEPARAMEVAL", "TWOPARAMEVAL", "STARTTIME", "ENDTIME", "OUTPUT", "EXEC", "CASE", "TRUE", "FALSE", "REGEX_STR", "SUBSTRING", "LOGICAL_OP", "ASC", "DESC", "MAXMATCH", "CONDITIONS", "INTLIT", "DECLIT", "STRLIT", "NUMBERS", "PLUS", "MINUS", "ASTERISK", "DIVISION", "ASSIGN", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LMIDDLE", "RMIDDLE", "COLON", "DOUBLE_QUOTE", "DOT", "ATTHERATE", "QUESTIONMARK", "STAR", "AND", "DOLLAR", "CAP", "NULL", "ID", "PIPE", "COMMA", "EXP", "UNSIGNED_INT", "ErrorCharacter"];
    GrammarLexer.prototype.grammarFileName = "GrammarLexer.g4";
    /* harmony default export */

    __webpack_exports__["default"] = GrammarLexer = GrammarLexer;
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/antlr/GrammarParser.js":
  /*!***********************************************************!*\
    !*** ./src/app/pages/home/logstab/antlr/GrammarParser.js ***!
    \***********************************************************/

  /*! exports provided: default */

  /***/
  function _src_app_pages_home_logstab_antlr_GrammarParserJs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! antlr4 */
    "./node_modules/antlr4/index.js");
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(antlr4__WEBPACK_IMPORTED_MODULE_0__); // Generated from GrammarParser.g4 by ANTLR 4.8
    // jshint ignore: start


    var GrammarParserListener = __webpack_require__(
    /*! ./GrammarParserListener */
    "./src/app/pages/home/logstab/antlr/GrammarParserListener.js").GrammarParserListener;

    var GrammarParserVisitor = __webpack_require__(
    /*! ./GrammarParserVisitor */
    "./src/app/pages/home/logstab/antlr/GrammarParserVisitor.js").GrammarParserVisitor;

    var grammarFileName = "GrammarParser.g4";
    var serializedATN = ["\x03\u608B\uA72A\u8133\uB9ED\u417C\u3BE7\u7786\u5964", "\x03Y\u0344\x04\x02\t\x02\x04\x03\t\x03\x04\x04\t", "\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07\t\x07\x04", "\b\t\b\x04\t\t\t\x04\n\t\n\x04\x0B\t\x0B\x04\f\t\f\x04", "\r\t\r\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04", "\x11\t\x11\x04\x12\t\x12\x04\x13\t\x13\x04\x14\t", "\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17\x04", "\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t", "\x1B\x04\x1C\t\x1C\x04\x1D\t\x1D\x04\x1E\t\x1E\x04", "\x1F\t\x1F\x04 \t \x04!\t!\x04\"\t\"\x04#\t#\x04$\t$\x04", "%\t%\x04&\t&\x04'\t'\x04(\t(\x04)\t)\x04*\t*\x04+\t+\x04", ",\t,\x04-\t-\x04.\t.\x04/\t/\x040\t0\x041\t1\x042\t2\x04", "3\t3\x03\x02\x03\x02\x03\x02\x07\x02j\n\x02\f\x02", "\x0E\x02m\x0B\x02\x03\x03\x03\x03\x03\x03\x03", "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03", "\x03\x05\x03y\n\x03\x03\x03\x03\x03\x03\x03\x07", "\x03~\n\x03\f\x03\x0E\x03\x81\x0B\x03\x03\x04\x03", "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03", "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03", "\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03", "\x04\x03\x04\x05\x04\x98\n\x04\x03\x05\x03\x05", "\x03\x05\x03\x05\x03\x05\x05\x05\x9F\n\x05\x03", "\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x07\x03", "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03", "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03", "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03", "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03", "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03", "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03", "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03", "\x07\x03\x07\x03\x07\x03\x07\x05\x07\xD5\n\x07", "\x03\b\x03\b\x05\b\xD9\n\b\x03\b\x03\b\x03\b\x03\b\x03", "\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03\t\x03", "\t\x03\t\x03\t\x05\t\xEB\n\t\x03\n\x03\n\x06\n\xEF\n", "\n\r\n\x0E\n\xF0\x03\n\x06\n\xF4\n\n\r\n\x0E\n\xF5\x03", "\n\x03\n\x06\n\xFA\n\n\r\n\x0E\n\xFB\x03\n\x03\n\x03", "\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x07\n\u0107\n\n", "\f\n\x0E\n\u010A\x0B\n\x03\x0B\x03\x0B\x03\x0B\x03", "\x0B\x03\x0B\x03\f\x03\f\x03\f\x03\r\x03\r\x03\r\x03", "\r\x03\r\x03\r\x07\r\u011A\n\r\f\r\x0E\r\u011D\x0B\r\x03", "\x0E\x03\x0E\x03\x0E\x03\x0F\x03\x0F\x03\x0F\x05", "\x0F\u0125\n\x0F\x03\x10\x03\x10\x03\x10\x03\x10", "\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11", "\x03\x11\x03\x11\x03\x11\x03\x11\x05\x11\u0135\n", "\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03", "\x11\x03\x11\x03\x11\x05\x11\u013F\n\x11\x03\x11", "\x03\x11\x03\x11\x03\x11\x05\x11\u0145\n\x11\x03", "\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03", "\x11\x03\x11\x05\x11\u014F\n\x11\x03\x11\x03\x11", "\x03\x11\x03\x11\x05\x11\u0155\n\x11\x05\x11\u0157", "\n\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11", "\x03\x11\x03\x11\x03\x11\x05\x11\u0161\n\x11\x03", "\x11\x03\x11\x03\x11\x03\x11\x05\x11\u0167\n\x11", "\x03\x11\x03\x11\x03\x11\x07\x11\u016C\n\x11\f\x11", "\x0E\x11\u016F\x0B\x11\x03\x11\x03\x11\x03\x11\x03", "\x11\x03\x11\x03\x11\x03\x11\x03\x11\x05\x11\u0179", "\n\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11", "\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11", "\x05\x11\u0186\n\x11\x03\x11\x03\x11\x03\x11\x03", "\x11\x05\x11\u018C\n\x11\x03\x11\x03\x11\x03\x11", "\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11", "\x03\x11\x03\x11\x03\x11\x05\x11\u019A\n\x11\x03", "\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x07", "\x11\u01A2\n\x11\f\x11\x0E\x11\u01A5\x0B\x11\x03\x11", "\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11", "\x03\x11\x05\x11\u01AF\n\x11\x03\x11\x03\x11\x03", "\x11\x03\x11\x05\x11\u01B5\n\x11\x03\x11\x03\x11", "\x03\x11\x03\x11\x03\x11\x03\x11\x07\x11\u01BD\n", "\x11\f\x11\x0E\x11\u01C0\x0B\x11\x05\x11\u01C2\n\x11", "\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12", "\x03\x12\x03\x12\x03\x12\x03\x12\x05\x12\u01CE\n", "\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03", "\x12\x03\x12\x03\x12\x05\x12\u01D8\n\x12\x03\x12", "\x03\x12\x03\x12\x03\x12\x05\x12\u01DE\n\x12\x03", "\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03", "\x12\x03\x12\x05\x12\u01E8\n\x12\x03\x12\x03\x12", "\x03\x12\x05\x12\u01ED\n\x12\x06\x12\u01EF\n\x12\r\x12", "\x0E\x12\u01F0\x03\x12\x03\x12\x03\x12\x03\x12\x03", "\x12\x03\x12\x03\x12\x03\x12\x05\x12\u01FB\n\x12", "\x03\x12\x03\x12\x03\x12\x03\x12\x05\x12\u0201\n", "\x12\x03\x12\x03\x12\x03\x12\x05\x12\u0206\n\x12", "\x06\x12\u0208\n\x12\r\x12\x0E\x12\u0209\x05\x12\u020C", "\n\x12\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13", "\x03\x13\x03\x13\x03\x13\x03\x13\x03\x13\x05\x13", "\u0218\n\x13\x03\x13\x03\x13\x03\x13\x03\x13\x07", "\x13\u021E\n\x13\f\x13\x0E\x13\u0221\x0B\x13\x05\x13", "\u0223\n\x13\x03\x14\x03\x14\x03\x14\x03\x14\x07", "\x14\u0229\n\x14\f\x14\x0E\x14\u022C\x0B\x14\x03\x14", "\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x07\x14", "\u0234\n\x14\f\x14\x0E\x14\u0237\x0B\x14\x03\x14\x03", "\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x05", "\x14\u0240\n\x14\x03\x14\x03\x14\x07\x14\u0244\n\x14", "\f\x14\x0E\x14\u0247\x0B\x14\x03\x14\x03\x14\x03", "\x14\x03\x14\x03\x14\x03\x14\x03\x14\x05\x14\u0250", "\n\x14\x03\x14\x03\x14\x03\x14\x03\x14\x07\x14", "\u0256\n\x14\f\x14\x0E\x14\u0259\x0B\x14\x03\x15\x03", "\x15\x03\x15\x03\x15\x05\x15\u025F\n\x15\x06\x15", "\u0261\n\x15\r\x15\x0E\x15\u0262\x03\x16\x03\x16\x03", "\x16\x03\x16\x07\x16\u0269\n\x16\f\x16\x0E\x16\u026C", "\x0B\x16\x03\x16\x03\x16\x03\x16\x03\x17\x03\x17", "\x07\x17\u0273\n\x17\f\x17\x0E\x17\u0276\x0B\x17\x03", "\x17\x03\x17\x03\x17\x05\x17\u027B\n\x17\x03\x18", "\x03\x18\x03\x18\x03\x18\x03\x18\x03\x18\x03\x19", "\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19", "\x05\x19\u028A\n\x19\x07\x19\u028C\n\x19\f\x19\x0E\x19", "\u028F\x0B\x19\x03\x1A\x03\x1A\x03\x1A\x07\x1A\u0294", "\n\x1A\f\x1A\x0E\x1A\u0297\x0B\x1A\x03\x1B\x03\x1B", "\x07\x1B\u029B\n\x1B\f\x1B\x0E\x1B\u029E\x0B\x1B\x03", "\x1B\x03\x1B\x03\x1B\x07\x1B\u02A3\n\x1B\f\x1B\x0E", "\x1B\u02A6\x0B\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B", "\x05\x1B\u02AC\n\x1B\x03\x1C\x03\x1C\x03\x1C\x03", "\x1C\x05\x1C\u02B2\n\x1C\x03\x1D\x03\x1D\x03\x1D", "\x07\x1D\u02B7\n\x1D\f\x1D\x0E\x1D\u02BA\x0B\x1D\x03", "\x1E\x03\x1E\x05\x1E\u02BE\n\x1E\x03\x1F\x05\x1F", "\u02C1\n\x1F\x03\x1F\x03\x1F\x03 \x03 \x03!\x03!\x05", "!\u02C9\n!\x03\"\x03\"\x03\"\x06\"\u02CE\n\"\r\"\x0E\"\u02CF", "\x03#\x03#\x03#\x03#\x03#\x05#\u02D7\n#\x03$\x03$\x03", "%\x03%\x05%\u02DD\n%\x03%\x03%\x03%\x03%\x05%\u02E3\n", "%\x03%\x03%\x05%\u02E7\n%\x03%\x03%\x03%\x03%\x03&\x03", "&\x03'\x03'\x03'\x03'\x03(\x03(\x03(\x03(\x03", "(\x07(\u02F8\n(\f(\x0E(\u02FB\x0B(\x03)\x03)\x03)\x03", "*\x03*\x03*\x07*\u0303\n*\f*\x0E*\u0306\x0B*\x03+\x03", "+\x03+\x03+\x03+\x07+\u030D\n+\f+\x0E+\u0310\x0B+\x03", ",\x03,\x03,\x03,\x03-\x03-\x03-\x07-\u0319\n-\f-\x0E", "-\u031C\x0B-\x03.\x03.\x03.\x05.\u0321\n.\x03.\x03.\x03", "/\x03/\x03/\x07/\u0328\n/\f/\x0E/\u032B\x0B/\x030\x03", "0\x030\x050\u0330\n0\x030\x030\x050\u0334\n0\x031\x03", "1\x031\x071\u0339\n1\f1\x0E1\u033C\x0B1\x032\x032\x03", "2\x032\x033\x033\x033\x02\x03\x044\x02\x04\x06\b", "\n\f\x0E\x10\x12\x14\x16\x18\x1A\x1C\x1E \"$&(*,.", "02468:<>@BDFHJLNPRTVXZ\\^`bd\x02\x10\x03\x02;=\x04\x02-", "-==\x04\x02;=WW\x04\x02-.==\x04\x02==LR\x04\x0224WW", "\x03\x0278\x03\x02\"#\x03\x02()\x04\x02;=SS\x03\x02", ";<\x03\x02?@\x04\x02==WW\x03\x02$%\x02\u039B\x02f\x03", "\x02\x02\x02\x04x\x03\x02\x02\x02\x06\x97\x03", "\x02\x02\x02\b\x9E\x03\x02\x02\x02\n\xA0\x03\x02", "\x02\x02\f\xD4\x03\x02\x02\x02\x0E\xD6\x03\x02", "\x02\x02\x10\xEA\x03\x02\x02\x02\x12\xEC\x03\x02", "\x02\x02\x14\u010B\x03\x02\x02\x02\x16\u0110\x03\x02", "\x02\x02\x18\u0113\x03\x02\x02\x02\x1A\u011E\x03\x02", "\x02\x02\x1C\u0121\x03\x02\x02\x02\x1E\u0126\x03\x02", "\x02\x02 \u01C1\x03\x02\x02\x02\"\u020B\x03\x02\x02", "\x02$\u0222\x03\x02\x02\x02&\u022A\x03\x02\x02\x02", "(\u025A\x03\x02\x02\x02*\u0264\x03\x02\x02\x02,\u027A", "\x03\x02\x02\x02.\u027C\x03\x02\x02\x020\u0282\x03", "\x02\x02\x022\u0290\x03\x02\x02\x024\u02AB\x03\x02", "\x02\x026\u02B1\x03\x02\x02\x028\u02B3\x03\x02\x02", "\x02:\u02BD\x03\x02\x02\x02<\u02C0\x03\x02\x02\x02", ">\u02C4\x03\x02\x02\x02@\u02C8\x03\x02\x02\x02B\u02CA", "\x03\x02\x02\x02D\u02D1\x03\x02\x02\x02F\u02D8\x03", "\x02\x02\x02H\u02DA\x03\x02\x02\x02J\u02EC\x03\x02", "\x02\x02L\u02EE\x03\x02\x02\x02N\u02F2\x03\x02\x02", "\x02P\u02FC\x03\x02\x02\x02R\u02FF\x03\x02\x02\x02", "T\u0307\x03\x02\x02\x02V\u0311\x03\x02\x02\x02X\u0315", "\x03\x02\x02\x02Z\u031D\x03\x02\x02\x02\\\u0324\x03", "\x02\x02\x02^\u0333\x03\x02\x02\x02`\u0335\x03\x02", "\x02\x02b\u033D\x03\x02\x02\x02d\u0341\x03\x02\x02", "\x02fk\x05\x04\x03\x02gh\x07U\x02\x02hj\x05\x06", "\x04\x02ig\x03\x02\x02\x02jm\x03\x02\x02\x02ki\x03", "\x02\x02\x02kl\x03\x02\x02\x02l\x03\x03\x02\x02", "\x02mk\x03\x02\x02\x02no\b\x03\x01\x02oy\x07=\x02", "\x02py\x07W\x02\x02qy\x07A\x02\x02rs\x07=\x02\x02", "st\x07J\x02\x02ty\x07=\x02\x02uv\x07=\x02\x02vw\x07", "J\x02\x02wy\x07W\x02\x02xn\x03\x02\x02\x02xp\x03", "\x02\x02\x02xq\x03\x02\x02\x02xr\x03\x02\x02\x02", "xu\x03\x02\x02\x02y\x7F\x03\x02\x02\x02z{\f\b\x02", "\x02{|\x076\x02\x02|~\x05\x04\x03\t}z\x03\x02\x02", "\x02~\x81\x03\x02\x02\x02\x7F}\x03\x02\x02\x02", "\x7F\x80\x03\x02\x02\x02\x80\x05\x03\x02\x02\x02", "\x81\x7F\x03\x02\x02\x02\x82\x83\x07\f\x02\x02", "\x83\x98\x05\f\x07\x02\x84\x85\x07\x0B\x02\x02", "\x85\x98\x05\n\x06\x02\x86\x98\x05\x0E\b\x02\x87", "\x98\x05H%\x02\x88\x98\x05P)\x02\x89\x98\x05\x10", "\t\x02\x8A\x98\x05\x12\n\x02\x8B\x98\x05\x16\f\x02", "\x8C\x98\x05\x14\x0B\x02\x8D\x98\x05\x18\r\x02", "\x8E\x98\x05\x1C\x0F\x02\x8F\x98\x05\x1A\x0E\x02", "\x90\x98\x05 \x11\x02\x91\x98\x05\"\x12\x02\x92", "\x98\x05$\x13\x02\x93\x98\x05(\x15\x02\x94\x98", "\x05*\x16\x02\x95\x98\x054\x1B\x02\x96\x98\x05", "D#\x02\x97\x82\x03\x02\x02\x02\x97\x84\x03\x02", "\x02\x02\x97\x86\x03\x02\x02\x02\x97\x87\x03\x02", "\x02\x02\x97\x88\x03\x02\x02\x02\x97\x89\x03\x02", "\x02\x02\x97\x8A\x03\x02\x02\x02\x97\x8B\x03\x02", "\x02\x02\x97\x8C\x03\x02\x02\x02\x97\x8D\x03\x02", "\x02\x02\x97\x8E\x03\x02\x02\x02\x97\x8F\x03\x02", "\x02\x02\x97\x90\x03\x02\x02\x02\x97\x91\x03\x02", "\x02\x02\x97\x92\x03\x02\x02\x02\x97\x93\x03\x02", "\x02\x02\x97\x94\x03\x02\x02\x02\x97\x95\x03\x02", "\x02\x02\x97\x96\x03\x02\x02\x02\x98\x07\x03\x02", "\x02\x02\x99\x9A\x07\f\x02\x02\x9A\x9F\x05\f\x07", "\x02\x9B\x9C\x07\x0B\x02\x02\x9C\x9F\x05\n\x06", "\x02\x9D\x9F\x05\x0E\b\x02\x9E\x99\x03\x02\x02", "\x02\x9E\x9B\x03\x02\x02\x02\x9E\x9D\x03\x02\x02", "\x02\x9F\t\x03\x02\x02\x02\xA0\xA1\x07=\x02\x02", "\xA1\xA2\x07C\x02\x02\xA2\xA3\x07W\x02\x02\xA3", "\xA4\x07=\x02\x02\xA4\x0B\x03\x02\x02\x02\xA5", "\xA6\x07=\x02\x02\xA6\xA7\x07C\x02\x02\xA7\xA8", "\x07*\x02\x02\xA8\xA9\x07D\x02\x02\xA9\xD5\x07", "E\x02\x02\xAA\xAB\x07=\x02\x02\xAB\xAC\x07C\x02", "\x02\xAC\xAD\x070\x02\x02\xAD\xAE\x07D\x02\x02", "\xAE\xAF\x07W\x02\x02\xAF\xD5\x07E\x02\x02\xB0", "\xB1\x07=\x02\x02\xB1\xB2\x07C\x02\x02\xB2\xB3", "\x07+\x02\x02\xB3\xB4\x07D\x02\x02\xB4\xB5\t\x02", "\x02\x02\xB5\xD5\x07E\x02\x02\xB6\xB7\x07=\x02", "\x02\xB7\xB8\x07C\x02\x02\xB8\xB9\x07,\x02\x02", "\xB9\xBA\x07D\x02\x02\xBA\xBB\t\x02\x02\x02\xBB", "\xBC\x07V\x02\x02\xBC\xBD\t\x02\x02\x02\xBD\xD5", "\x07E\x02\x02\xBE\xBF\x07=\x02\x02\xBF\xC0\x07", "C\x02\x02\xC0\xC1\x071\x02\x02\xC1\xC2\x07D\x02", "\x02\xC2\xC3\t\x02\x02\x02\xC3\xC4\x07:\x02\x02", "\xC4\xC5\x07W\x02\x02\xC5\xC6\x07V\x02\x02\xC6", "\xC7\x07W\x02\x02\xC7\xC8\x07V\x02\x02\xC8\xC9", "\x07W\x02\x02\xC9\xD5\x07E\x02\x02\xCA\xCB\x07", "=\x02\x02\xCB\xCC\x07C\x02\x02\xCC\xCD\x075\x02", "\x02\xCD\xCE\x07D\x02\x02\xCE\xCF\t\x02\x02\x02", "\xCF\xD0\x07V\x02\x02\xD0\xD1\t\x02\x02\x02\xD1", "\xD2\x07V\x02\x02\xD2\xD3\t\x02\x02\x02\xD3\xD5", "\x07E\x02\x02\xD4\xA5\x03\x02\x02\x02\xD4\xAA", "\x03\x02\x02\x02\xD4\xB0\x03\x02\x02\x02\xD4\xB6", "\x03\x02\x02\x02\xD4\xBE\x03\x02\x02\x02\xD4\xCA", "\x03\x02\x02\x02\xD5\r\x03\x02\x02\x02\xD6\xD8", "\x07\x0E\x02\x02\xD7\xD9\x07;\x02\x02\xD8\xD7", "\x03\x02\x02\x02\xD8\xD9\x03\x02\x02\x02\xD9\xDA", "\x03\x02\x02\x02\xDA\xDB\x07=\x02\x02\xDB\xDC", "\x07U\x02\x02\xDC\xDD\x05\x06\x04\x02\xDD\x0F", "\x03\x02\x02\x02\xDE\xDF\x07\x11\x02\x02\xDF\xE0", "\t\x03\x02\x02\xE0\xE1\x07:\x02\x02\xE1\xEB\t\x04", "\x02\x02\xE2\xE3\x07\x11\x02\x02\xE3\xE4\t\x03", "\x02\x02\xE4\xE5\x07:\x02\x02\xE5\xE6\t\x04\x02", "\x02\xE6\xE7\x076\x02\x02\xE7\xE8\t\x05\x02\x02", "\xE8\xE9\x07:\x02\x02\xE9\xEB\t\x04\x02\x02\xEA", "\xDE\x03\x02\x02\x02\xEA\xE2\x03\x02\x02\x02\xEB", "\x11\x03\x02\x02\x02\xEC\xEE\x07\x12\x02\x02\xED", "\xEF\t\x06\x02\x02\xEE\xED\x03\x02\x02\x02\xEF", "\xF0\x03\x02\x02\x02\xF0\xEE\x03\x02\x02\x02\xF0", "\xF1\x03\x02\x02\x02\xF1\xF3\x03\x02\x02\x02\xF2", "\xF4\t\x06\x02\x02\xF3\xF2\x03\x02\x02\x02\xF4", "\xF5\x03\x02\x02\x02\xF5\xF3\x03\x02\x02\x02\xF5", "\xF6\x03\x02\x02\x02\xF6\xF7\x03\x02\x02\x02\xF7", "\xF9\x07/\x02\x02\xF8\xFA\t\x06\x02\x02\xF9\xF8", "\x03\x02\x02\x02\xFA\xFB\x03\x02\x02\x02\xFB\xF9", "\x03\x02\x02\x02\xFB\xFC\x03\x02\x02\x02\xFC\u0108", "\x03\x02\x02\x02\xFD\xFE\x07V\x02\x02\xFE\u0107", "\x07=\x02\x02\xFF\u0107\x07L\x02\x02\u0100\u0107\x07", "M\x02\x02\u0101\u0107\x07N\x02\x02\u0102\u0107\x07O\x02", "\x02\u0103\u0107\x07Q\x02\x02\u0104\u0107\x07R\x02\x02", "\u0105\u0107\x07P\x02\x02\u0106\xFD\x03\x02\x02\x02", "\u0106\xFF\x03\x02\x02\x02\u0106\u0100\x03\x02\x02\x02", "\u0106\u0101\x03\x02\x02\x02\u0106\u0102\x03\x02\x02\x02", "\u0106\u0103\x03\x02\x02\x02\u0106\u0104\x03\x02\x02\x02", "\u0106\u0105\x03\x02\x02\x02\u0107\u010A\x03\x02\x02\x02", "\u0108\u0106\x03\x02\x02\x02\u0108\u0109\x03\x02\x02\x02", "\u0109\x13\x03\x02\x02\x02\u010A\u0108\x03\x02\x02\x02", "\u010B\u010C\x07\x13\x02\x02\u010C\u010D\x07F\x02\x02", "\u010D\u010E\x05\x02\x02\x02\u010E\u010F\x07G\x02\x02", "\u010F\x15\x03\x02\x02\x02\u0110\u0111\x07\x14\x02\x02", "\u0111\u0112\x07=\x02\x02\u0112\x17\x03\x02\x02\x02", "\u0113\u0114\x07\x15\x02\x02\u0114\u0115\x07=\x02\x02", "\u0115\u0116\x07C\x02\x02\u0116\u0117\t\x07\x02\x02\u0117", "\u011B\x03\x02\x02\x02\u0118\u011A\x07=\x02\x02\u0119", "\u0118\x03\x02\x02\x02\u011A\u011D\x03\x02\x02\x02\u011B", "\u0119\x03\x02\x02\x02\u011B\u011C\x03\x02\x02\x02\u011C", "\x19\x03\x02\x02\x02\u011D\u011B\x03\x02\x02\x02\u011E", "\u011F\x07\x16\x02\x02\u011F\u0120\x07=\x02\x02\u0120", "\x1B\x03\x02\x02\x02\u0121\u0122\x07\x17\x02\x02\u0122", "\u0124\x07=\x02\x02\u0123\u0125\x05\x1E\x10\x02\u0124", "\u0123\x03\x02\x02\x02\u0124\u0125\x03\x02\x02\x02\u0125", "\x1D\x03\x02\x02\x02\u0126\u0127\x07=\x02\x02\u0127", "\u0128\x07C\x02\x02\u0128\u0129\x07X\x02\x02\u0129\x1F", "\x03\x02\x02\x02\u012A\u012B\x07\x18\x02\x02\u012B\u01C2", "\x07=\x02\x02\u012C\u012D\x07\x18\x02\x02\u012D\u012E", "\x07\b\x02\x02\u012E\u012F\x07D\x02\x02\u012F\u0134\x07", "=\x02\x02\u0130\u0135\x07E\x02\x02\u0131\u0132\x07E\x02", "\x02\u0132\u0133\x07\x06\x02\x02\u0133\u0135\x07=\x02", "\x02\u0134\u0130\x03\x02\x02\x02\u0134\u0131\x03\x02\x02", "\x02\u0135\u01C2\x03\x02\x02\x02\u0136\u0137\x07\x18\x02", "\x02\u0137\u0138\x07\t\x02\x02\u0138\u0139\x07D\x02\x02", "\u0139\u013A\x05<\x1F\x02\u013A\u013E\x07V\x02\x02\u013B", "\u013F\x07=\x02\x02\u013C\u013F\x05<\x1F\x02\u013D\u013F", "\x07W\x02\x02\u013E\u013B\x03\x02\x02\x02\u013E\u013C", "\x03\x02\x02\x02\u013E\u013D\x03\x02\x02\x02\u013F\u0144", "\x03\x02\x02\x02\u0140\u0145\x07E\x02\x02\u0141\u0142", "\x07E\x02\x02\u0142\u0143\x07\x06\x02\x02\u0143\u0145", "\x07=\x02\x02\u0144\u0140\x03\x02\x02\x02\u0144\u0141", "\x03\x02\x02\x02\u0145\u01C2\x03\x02\x02\x02\u0146\u0147", "\x07\x18\x02\x02\u0147\u0148\x07\b\x02\x02\u0148\u0149", "\x07D\x02\x02\u0149\u014E\x07=\x02\x02\u014A\u014F\x07", "E\x02\x02\u014B\u014C\x07E\x02\x02\u014C\u014D\x07\x06", "\x02\x02\u014D\u014F\x07=\x02\x02\u014E\u014A\x03\x02", "\x02\x02\u014E\u014B\x03\x02\x02\x02\u014F\u0150\x03\x02", "\x02\x02\u0150\u0156\x07\x05\x02\x02\u0151\u0157\x07=", "\x02\x02\u0152\u0154\x07=\x02\x02\u0153\u0155\x07V\x02", "\x02\u0154\u0153\x03\x02\x02\x02\u0154\u0155\x03\x02\x02", "\x02\u0155\u0157\x03\x02\x02\x02\u0156\u0151\x03\x02\x02", "\x02\u0156\u0152\x03\x02\x02\x02\u0157\u01C2\x03\x02\x02", "\x02\u0158\u0159\x07\x18\x02\x02\u0159\u015A\x07\t\x02", "\x02\u015A\u015B\x07D\x02\x02\u015B\u015C\x05<\x1F\x02", "\u015C\u0160\x07V\x02\x02\u015D\u0161\x07=\x02\x02\u015E", "\u0161\x05<\x1F\x02\u015F\u0161\x07W\x02\x02\u0160\u015D", "\x03\x02\x02\x02\u0160\u015E\x03\x02\x02\x02\u0160\u015F", "\x03\x02\x02\x02\u0161\u0166\x03\x02\x02\x02\u0162\u0167", "\x07E\x02\x02\u0163\u0164\x07E\x02\x02\u0164\u0165\x07", "\x06\x02\x02\u0165\u0167\x07=\x02\x02\u0166\u0162\x03", "\x02\x02\x02\u0166\u0163\x03\x02\x02\x02\u0167\u0168\x03", "\x02\x02\x02\u0168\u0169\x07\x05\x02\x02\u0169\u016D\x07", "=\x02\x02\u016A\u016C\x07V\x02\x02\u016B\u016A\x03\x02", "\x02\x02\u016C\u016F\x03\x02\x02\x02\u016D\u016B\x03\x02", "\x02\x02\u016D\u016E\x03\x02\x02\x02\u016E\u01C2\x03\x02", "\x02\x02\u016F\u016D\x03\x02\x02\x02\u0170\u0171\x07\x18", "\x02\x02\u0171\u0172\x07\b\x02\x02\u0172\u0173\x07D\x02", "\x02\u0173\u0178\x07=\x02\x02\u0174\u0179\x07E\x02\x02", "\u0175\u0176\x07E\x02\x02\u0176\u0177\x07\x06\x02\x02", "\u0177\u0179\x07=\x02\x02\u0178\u0174\x03\x02\x02\x02", "\u0178\u0175\x03\x02\x02\x02\u0179\u017A\x03\x02\x02\x02", "\u017A\u017B\x07\x07\x02\x02\u017B\u017C\x07C\x02\x02", "\u017C\u01C2\x07=\x02\x02\u017D\u017E\x07\x18\x02\x02", "\u017E\u017F\x07\t\x02\x02\u017F\u0180\x07D\x02\x02\u0180", "\u0181\x05<\x1F\x02\u0181\u0185\x07V\x02\x02\u0182\u0186", "\x07=\x02\x02\u0183\u0186\x05<\x1F\x02\u0184\u0186\x07", "W\x02\x02\u0185\u0182\x03\x02\x02\x02\u0185\u0183\x03", "\x02\x02\x02\u0185\u0184\x03\x02\x02\x02\u0186\u018B\x03", "\x02\x02\x02\u0187\u018C\x07E\x02\x02\u0188\u0189\x07", "E\x02\x02\u0189\u018A\x07\x06\x02\x02\u018A\u018C\x07", "=\x02\x02\u018B\u0187\x03\x02\x02\x02\u018B\u0188\x03", "\x02\x02\x02\u018C\u018D\x03\x02\x02\x02\u018D\u018E\x07", "\x07\x02\x02\u018E\u018F\x07C\x02\x02\u018F\u0190\x07", "=\x02\x02\u0190\u01C2\x03\x02\x02\x02\u0191\u0192\x07", "\x18\x02\x02\u0192\u0193\x07\b\x02\x02\u0193\u0194\x07", "D\x02\x02\u0194\u0199\x07=\x02\x02\u0195\u019A\x07E\x02", "\x02\u0196\u0197\x07E\x02\x02\u0197\u0198\x07\x06\x02", "\x02\u0198\u019A\x07=\x02\x02\u0199\u0195\x03\x02\x02", "\x02\u0199\u0196\x03\x02\x02\x02\u019A\u019B\x03\x02\x02", "\x02\u019B\u019C\x07\x07\x02\x02\u019C\u019D\x07C\x02", "\x02\u019D\u019E\x07=\x02\x02\u019E\u019F\x07\x05\x02", "\x02\u019F\u01A3\x07=\x02\x02\u01A0\u01A2\x07V\x02\x02", "\u01A1\u01A0\x03\x02\x02\x02\u01A2\u01A5\x03\x02\x02\x02", "\u01A3\u01A1\x03\x02\x02\x02\u01A3\u01A4\x03\x02\x02\x02", "\u01A4\u01C2\x03\x02\x02\x02\u01A5\u01A3\x03\x02\x02\x02", "\u01A6\u01A7\x07\x18\x02\x02\u01A7\u01A8\x07\t\x02\x02", "\u01A8\u01A9\x07D\x02\x02\u01A9\u01AA\x05<\x1F\x02\u01AA", "\u01AE\x07V\x02\x02\u01AB\u01AF\x07=\x02\x02\u01AC\u01AF", "\x05<\x1F\x02\u01AD\u01AF\x07W\x02\x02\u01AE\u01AB\x03", "\x02\x02\x02\u01AE\u01AC\x03\x02\x02\x02\u01AE\u01AD\x03", "\x02\x02\x02\u01AF\u01B4\x03\x02\x02\x02\u01B0\u01B5\x07", "E\x02\x02\u01B1\u01B2\x07E\x02\x02\u01B2\u01B3\x07\x06", "\x02\x02\u01B3\u01B5\x07=\x02\x02\u01B4\u01B0\x03\x02", "\x02\x02\u01B4\u01B1\x03\x02\x02\x02\u01B5\u01B6\x03\x02", "\x02\x02\u01B6\u01B7\x07\x07\x02\x02\u01B7\u01B8\x07C", "\x02\x02\u01B8\u01B9\x07=\x02\x02\u01B9\u01BA\x07\x05", "\x02\x02\u01BA\u01BE\x07=\x02\x02\u01BB\u01BD\x07V\x02", "\x02\u01BC\u01BB\x03\x02\x02\x02\u01BD\u01C0\x03\x02\x02", "\x02\u01BE\u01BC\x03\x02\x02\x02\u01BE\u01BF\x03\x02\x02", "\x02\u01BF\u01C2\x03\x02\x02\x02\u01C0\u01BE\x03\x02\x02", "\x02\u01C1\u012A\x03\x02\x02\x02\u01C1\u012C\x03\x02\x02", "\x02\u01C1\u0136\x03\x02\x02\x02\u01C1\u0146\x03\x02\x02", "\x02\u01C1\u0158\x03\x02\x02\x02\u01C1\u0170\x03\x02\x02", "\x02\u01C1\u017D\x03\x02\x02\x02\u01C1\u0191\x03\x02\x02", "\x02\u01C1\u01A6\x03\x02\x02\x02\u01C2!\x03\x02\x02", "\x02\u01C3\u01C4\x07\x18\x02\x02\u01C4\u020C\x07=\x02", "\x02\u01C5\u01C6\x07\x19\x02\x02\u01C6\u01C7\x07\b\x02", "\x02\u01C7\u01C8\x07D\x02\x02\u01C8\u01CD\x07=\x02\x02", "\u01C9\u01CE\x07E\x02\x02\u01CA\u01CB\x07E\x02\x02\u01CB", "\u01CC\x07\x06\x02\x02\u01CC\u01CE\x07=\x02\x02\u01CD", "\u01C9\x03\x02\x02\x02\u01CD\u01CA\x03\x02\x02\x02\u01CE", "\u020C\x03\x02\x02\x02\u01CF\u01D0\x07\x19\x02\x02\u01D0", "\u01D1\x07\t\x02\x02\u01D1\u01D2\x07D\x02\x02\u01D2\u01D3", "\x05<\x1F\x02\u01D3\u01D7\x07V\x02\x02\u01D4\u01D8\x07", "=\x02\x02\u01D5\u01D8\x05<\x1F\x02\u01D6\u01D8\x07W\x02", "\x02\u01D7\u01D4\x03\x02\x02\x02\u01D7\u01D5\x03\x02\x02", "\x02\u01D7\u01D6\x03\x02\x02\x02\u01D8\u01DD\x03\x02\x02", "\x02\u01D9\u01DE\x07E\x02\x02\u01DA\u01DB\x07E\x02\x02", "\u01DB\u01DC\x07\x06\x02\x02\u01DC\u01DE\x07=\x02\x02", "\u01DD\u01D9\x03\x02\x02\x02\u01DD\u01DA\x03\x02\x02\x02", "\u01DE\u020C\x03\x02\x02\x02\u01DF\u01E0\x07\x19\x02\x02", "\u01E0\u01E1\x07\b\x02\x02\u01E1\u01E2\x07D\x02\x02\u01E2", "\u01E7\x07=\x02\x02\u01E3\u01E8\x07E\x02\x02\u01E4\u01E5", "\x07E\x02\x02\u01E5\u01E6\x07\x06\x02\x02\u01E6\u01E8", "\x07=\x02\x02\u01E7\u01E3\x03\x02\x02\x02\u01E7\u01E4", "\x03\x02\x02\x02\u01E8\u01E9\x03\x02\x02\x02\u01E9\u01EE", "\x07\x05\x02\x02\u01EA\u01EC\x07=\x02\x02\u01EB\u01ED", "\x07V\x02\x02\u01EC\u01EB\x03\x02\x02\x02\u01EC\u01ED", "\x03\x02\x02\x02\u01ED\u01EF\x03\x02\x02\x02\u01EE\u01EA", "\x03\x02\x02\x02\u01EF\u01F0\x03\x02\x02\x02\u01F0\u01EE", "\x03\x02\x02\x02\u01F0\u01F1\x03\x02\x02\x02\u01F1\u020C", "\x03\x02\x02\x02\u01F2\u01F3\x07\x19\x02\x02\u01F3\u01F4", "\x07\t\x02\x02\u01F4\u01F5\x07D\x02\x02\u01F5\u01F6\x05", "<\x1F\x02\u01F6\u01FA\x07V\x02\x02\u01F7\u01FB\x07=\x02", "\x02\u01F8\u01FB\x05<\x1F\x02\u01F9\u01FB\x07W\x02\x02", "\u01FA\u01F7\x03\x02\x02\x02\u01FA\u01F8\x03\x02\x02\x02", "\u01FA\u01F9\x03\x02\x02\x02\u01FB\u0200\x03\x02\x02\x02", "\u01FC\u0201\x07E\x02\x02\u01FD\u01FE\x07E\x02\x02\u01FE", "\u01FF\x07\x06\x02\x02\u01FF\u0201\x07=\x02\x02\u0200", "\u01FC\x03\x02\x02\x02\u0200\u01FD\x03\x02\x02\x02\u0201", "\u0202\x03\x02\x02\x02\u0202\u0207\x07\x05\x02\x02\u0203", "\u0205\x07=\x02\x02\u0204\u0206\x07V\x02\x02\u0205\u0204", "\x03\x02\x02\x02\u0205\u0206\x03\x02\x02\x02\u0206\u0208", "\x03\x02\x02\x02\u0207\u0203\x03\x02\x02\x02\u0208\u0209", "\x03\x02\x02\x02\u0209\u0207\x03\x02\x02\x02\u0209\u020A", "\x03\x02\x02\x02\u020A\u020C\x03\x02\x02\x02\u020B\u01C3", "\x03\x02\x02\x02\u020B\u01C5\x03\x02\x02\x02\u020B\u01CF", "\x03\x02\x02\x02\u020B\u01DF\x03\x02\x02\x02\u020B\u01F2", "\x03\x02\x02\x02\u020C#\x03\x02\x02\x02\u020D\u020E", "\x07\x1A\x02\x02\u020E\u0223\x07=\x02\x02\u020F\u0210", "\x07\x1A\x02\x02\u0210\u0211\x07=\x02\x02\u0211\u0212", "\x07\x06\x02\x02\u0212\u0223\x07=\x02\x02\u0213\u0214", "\x07\x1A\x02\x02\u0214\u0217\x07=\x02\x02\u0215\u0216", "\x07\x06\x02\x02\u0216\u0218\x07=\x02\x02\u0217\u0215", "\x03\x02\x02\x02\u0217\u0218\x03\x02\x02\x02\u0218\u0219", "\x03\x02\x02\x02\u0219\u021A\x07\x05\x02\x02\u021A\u021F", "\x07=\x02\x02\u021B\u021C\x07V\x02\x02\u021C\u021E\x07", "=\x02\x02\u021D\u021B\x03\x02\x02\x02\u021E\u0221\x03", "\x02\x02\x02\u021F\u021D\x03\x02\x02\x02\u021F\u0220\x03", "\x02\x02\x02\u0220\u0223\x03\x02\x02\x02\u0221\u021F\x03", "\x02\x02\x02\u0222\u020D\x03\x02\x02\x02\u0222\u020F\x03", "\x02\x02\x02\u0222\u0213\x03\x02\x02\x02\u0223%\x03", "\x02\x02\x02\u0224\u0225\x07\b\x02\x02\u0225\u0226\x07", "D\x02\x02\u0226\u0227\x07=\x02\x02\u0227\u0229\x07E\x02", "\x02\u0228\u0224\x03\x02\x02\x02\u0229\u022C\x03\x02\x02", "\x02\u022A\u0228\x03\x02\x02\x02\u022A\u022B\x03\x02\x02", "\x02\u022B\u0235\x03\x02\x02\x02\u022C\u022A\x03\x02\x02", "\x02\u022D\u022E\x07\b\x02\x02\u022E\u022F\x07D\x02\x02", "\u022F\u0230\x07=\x02\x02\u0230\u0231\x07E\x02\x02\u0231", "\u0232\x07\x06\x02\x02\u0232\u0234\x07=\x02\x02\u0233", "\u022D\x03\x02\x02\x02\u0234\u0237\x03\x02\x02\x02\u0235", "\u0233\x03\x02\x02\x02\u0235\u0236\x03\x02\x02\x02\u0236", "\u0245\x03\x02\x02\x02\u0237\u0235\x03\x02\x02\x02\u0238", "\u0239\x07\t\x02\x02\u0239\u023A\x07D\x02\x02\u023A\u023B", "\x05<\x1F\x02\u023B\u023F\x07V\x02\x02\u023C\u0240\x07", "=\x02\x02\u023D\u0240\x05<\x1F\x02\u023E\u0240\x07W\x02", "\x02\u023F\u023C\x03\x02\x02\x02\u023F\u023D\x03\x02\x02", "\x02\u023F\u023E\x03\x02\x02\x02\u0240\u0241\x03\x02\x02", "\x02\u0241\u0242\x07E\x02\x02\u0242\u0244\x03\x02\x02", "\x02\u0243\u0238\x03\x02\x02\x02\u0244\u0247\x03\x02\x02", "\x02\u0245\u0243\x03\x02\x02\x02\u0245\u0246\x03\x02\x02", "\x02\u0246\u0257\x03\x02\x02\x02\u0247\u0245\x03\x02\x02", "\x02\u0248\u0249\x07\t\x02\x02\u0249\u024A\x07D\x02\x02", "\u024A\u024B\x05<\x1F\x02\u024B\u024F\x07V\x02\x02\u024C", "\u0250\x07=\x02\x02\u024D\u0250\x05<\x1F\x02\u024E\u0250", "\x07W\x02\x02\u024F\u024C\x03\x02\x02\x02\u024F\u024D", "\x03\x02\x02\x02\u024F\u024E\x03\x02\x02\x02\u0250\u0251", "\x03\x02\x02\x02\u0251\u0252\x07E\x02\x02\u0252\u0253", "\x07\x06\x02\x02\u0253\u0254\x07=\x02\x02\u0254\u0256", "\x03\x02\x02\x02\u0255\u0248\x03\x02\x02\x02\u0256\u0259", "\x03\x02\x02\x02\u0257\u0255\x03\x02\x02\x02\u0257\u0258", "\x03\x02\x02\x02\u0258'\x03\x02\x02\x02\u0259\u0257", "\x03\x02\x02\x02\u025A\u025B\x07\x1B\x02\x02\u025B\u0260", "\t\b\x02\x02\u025C\u025E\x07=\x02\x02\u025D\u025F\x07V\x02", "\x02\u025E\u025D\x03\x02\x02\x02\u025E\u025F\x03\x02\x02", "\x02\u025F\u0261\x03\x02\x02\x02\u0260\u025C\x03\x02\x02", "\x02\u0261\u0262\x03\x02\x02\x02\u0262\u0260\x03\x02\x02", "\x02\u0262\u0263\x03\x02\x02\x02\u0263)\x03\x02\x02", "\x02\u0264\u0265\x07\x1D\x02\x02\u0265\u026A\x05,\x17", "\x02\u0266\u0267\x07V\x02\x02\u0267\u0269\x05,\x17\x02", "\u0268\u0266\x03\x02\x02\x02\u0269\u026C\x03\x02\x02\x02", "\u026A\u0268\x03\x02\x02\x02\u026A\u026B\x03\x02\x02\x02", "\u026B\u026D\x03\x02\x02\x02\u026C\u026A\x03\x02\x02\x02", "\u026D\u026E\x07\x05\x02\x02\u026E\u026F\x052\x1A\x02", "\u026F+\x03\x02\x02\x02\u0270\u0274\x05.\x18\x02\u0271", "\u0273\t\t\x02\x02\u0272\u0271\x03\x02\x02\x02\u0273\u0276", "\x03\x02\x02\x02\u0274\u0272\x03\x02\x02\x02\u0274\u0275", "\x03\x02\x02\x02\u0275\u0277\x03\x02\x02\x02\u0276\u0274", "\x03\x02\x02\x02\u0277\u0278\x07=\x02\x02\u0278\u027B", "\x03\x02\x02\x02\u0279\u027B\x07=\x02\x02\u027A\u0270", "\x03\x02\x02\x02\u027A\u0279\x03\x02\x02\x02\u027B-", "\x03\x02\x02\x02\u027C\u027D\t\n\x02\x02\u027D\u027E\x07", "C\x02\x02\u027E\u027F\x07H\x02\x02\u027F\u0280\x050\x19", "\x02\u0280\u0281\x07I\x02\x02\u0281/\x03\x02\x02\x02", "\u0282\u028D\t\x0B\x02\x02\u0283\u0289\x07V\x02\x02\u0284", "\u028A\x07=\x02\x02\u0285\u028A\x03\x02\x02\x02\u0286", "\u028A\x07;\x02\x02\u0287\u028A\x07<\x02\x02\u0288\u028A", "\x07S\x02\x02\u0289\u0284\x03\x02\x02\x02\u0289\u0285", "\x03\x02\x02\x02\u0289\u0286\x03\x02\x02\x02\u0289\u0287", "\x03\x02\x02\x02\u0289\u0288\x03\x02\x02\x02\u028A\u028C", "\x03\x02\x02\x02\u028B\u0283\x03\x02\x02\x02\u028C\u028F", "\x03\x02\x02\x02\u028D\u028B\x03\x02\x02\x02\u028D\u028E", "\x03\x02\x02\x02\u028E1\x03\x02\x02\x02\u028F\u028D", "\x03\x02\x02\x02\u0290\u0295\x07=\x02\x02\u0291\u0292", "\x07V\x02\x02\u0292\u0294\x07=\x02\x02\u0293\u0291\x03", "\x02\x02\x02\u0294\u0297\x03\x02\x02\x02\u0295\u0293\x03", "\x02\x02\x02\u0295\u0296\x03\x02\x02\x02\u02963\x03", "\x02\x02\x02\u0297\u0295\x03\x02\x02\x02\u0298\u029C\x07", "\x1E\x02\x02\u0299\u029B\x056\x1C\x02\u029A\u0299\x03", "\x02\x02\x02\u029B\u029E\x03\x02\x02\x02\u029C\u029A\x03", "\x02\x02\x02\u029C\u029D\x03\x02\x02\x02\u029D\u029F\x03", "\x02\x02\x02\u029E\u029C\x03\x02\x02\x02\u029F\u02AC\x05", "8\x1D\x02\u02A0\u02A4\x07\x1E\x02\x02\u02A1\u02A3\x05", "6\x1C\x02\u02A2\u02A1\x03\x02\x02\x02\u02A3\u02A6\x03", "\x02\x02\x02\u02A4\u02A2\x03\x02\x02\x02\u02A4\u02A5\x03", "\x02\x02\x02\u02A5\u02A7\x03\x02\x02\x02\u02A6\u02A4\x03", "\x02\x02\x02\u02A7\u02A8\x058\x1D\x02\u02A8\u02A9\x07", "\x05\x02\x02\u02A9\u02AA\x058\x1D\x02\u02AA\u02AC\x03", "\x02\x02\x02\u02AB\u0298\x03\x02\x02\x02\u02AB\u02A0\x03", "\x02\x02\x02\u02AC5\x03\x02\x02\x02\u02AD\u02AE\x07", "!\x02\x02\u02AE\u02AF\x07C\x02\x02\u02AF\u02B2\t\f\x02\x02", "\u02B0\u02B2\t\f\x02\x02\u02B1\u02AD\x03\x02\x02\x02\u02B1", "\u02B0\x03\x02\x02\x02\u02B27\x03\x02\x02\x02\u02B3", "\u02B8\x07=\x02\x02\u02B4\u02B5\x07V\x02\x02\u02B5\u02B7", "\x07=\x02\x02\u02B6\u02B4\x03\x02\x02\x02\u02B7\u02BA", "\x03\x02\x02\x02\u02B8\u02B6\x03\x02\x02\x02\u02B8\u02B9", "\x03\x02\x02\x02\u02B99\x03\x02\x02\x02\u02BA\u02B8", "\x03\x02\x02\x02\u02BB\u02BE\x07\x1C\x02\x02\u02BC\u02BE", "\x05@!\x02\u02BD\u02BB\x03\x02\x02\x02\u02BD\u02BC\x03", "\x02\x02\x02\u02BE;\x03\x02\x02\x02\u02BF\u02C1\x05", "> \x02\u02C0\u02BF\x03\x02\x02\x02\u02C0\u02C1\x03\x02", "\x02\x02\u02C1\u02C2\x03\x02\x02\x02\u02C2\u02C3\x05@", "!\x02\u02C3=\x03\x02\x02\x02\u02C4\u02C5\t\r\x02\x02\u02C5", "?\x03\x02\x02\x02\u02C6\u02C9\x07X\x02\x02\u02C7\u02C9", "\x05B\"\x02\u02C8\u02C6\x03\x02\x02\x02\u02C8\u02C7\x03", "\x02\x02\x02\u02C9A\x03\x02\x02\x02\u02CA\u02CB\x07", "X\x02\x02\u02CB\u02CD\x07L\x02\x02\u02CC\u02CE\x07X\x02", "\x02\u02CD\u02CC\x03\x02\x02\x02\u02CE\u02CF\x03\x02\x02", "\x02\u02CF\u02CD\x03\x02\x02\x02\u02CF\u02D0\x03\x02\x02", "\x02\u02D0C\x03\x02\x02\x02\u02D1\u02D2\x07\x1F\x02", "\x02\u02D2\u02D3\x07 \x02\x02\u02D3\u02D4\x07J\x02\x02", "\u02D4\u02D6\x05F$\x02\u02D5\u02D7\x05\x10\t\x02\u02D6\u02D5", "\x03\x02\x02\x02\u02D6\u02D7\x03\x02\x02\x02\u02D7E", "\x03\x02\x02\x02\u02D8\u02D9\t\x0E\x02\x02\u02D9G\x03", "\x02\x02\x02\u02DA\u02DC\x07\x0F\x02\x02\u02DB\u02DD\x05", "J&\x02\u02DC\u02DB\x03\x02\x02\x02\u02DC\u02DD\x03\x02", "\x02\x02\u02DD\u02DE\x03\x02\x02\x02\u02DE\u02DF\x07&", "\x02\x02\u02DF\u02E2\x07=\x02\x02\u02E0\u02E3\x05L'\x02", "\u02E1\u02E3\x05N(\x02\u02E2\u02E0\x03\x02\x02\x02\u02E2", "\u02E1\x03\x02\x02\x02\u02E2\u02E3\x03\x02\x02\x02\u02E3", "\u02E6\x03\x02\x02\x02\u02E4\u02E7\x05L'\x02\u02E5\u02E7", "\x05N(\x02\u02E6\u02E4\x03\x02\x02\x02\u02E6\u02E5\x03", "\x02\x02\x02\u02E6\u02E7\x03\x02\x02\x02\u02E7\u02E8\x03", "\x02\x02\x02\u02E8\u02E9\x07F\x02\x02\u02E9\u02EA\x05", "\x02\x02\x02\u02EA\u02EB\x07F\x02\x02\u02EBI\x03\x02", "\x02\x02\u02EC\u02ED\t\x0F\x02\x02\u02EDK\x03\x02\x02", "\x02\u02EE\u02EF\x079\x02\x02\u02EF\u02F0\x07J\x02\x02", "\u02F0\u02F1\x07;\x02\x02\u02F1M\x03\x02\x02\x02\u02F2", "\u02F3\x07'\x02\x02\u02F3\u02F4\x07J\x02\x02\u02F4\u02F9", "\x07=\x02\x02\u02F5\u02F6\x07V\x02\x02\u02F6\u02F8\x07", "=\x02\x02\u02F7\u02F5\x03\x02\x02\x02\u02F8\u02FB\x03", "\x02\x02\x02\u02F9\u02F7\x03\x02\x02\x02\u02F9\u02FA\x03", "\x02\x02\x02\u02FAO\x03\x02\x02\x02\u02FB\u02F9\x03", "\x02\x02\x02\u02FC\u02FD\x07\x10\x02\x02\u02FD\u02FE\x05", "R*\x02\u02FEQ\x03\x02\x02\x02\u02FF\u0304\x07=\x02\x02", "\u0300\u0301\x07V\x02\x02\u0301\u0303\x07=\x02\x02\u0302", "\u0300\x03\x02\x02\x02\u0303\u0306\x03\x02\x02\x02\u0304", "\u0302\x03\x02\x02\x02\u0304\u0305\x03\x02\x02\x02\u0305", "S\x03\x02\x02\x02\u0306\u0304\x03\x02\x02\x02\u0307", "\u0308\x07=\x02\x02\u0308\u0309\x07J\x02\x02\u0309\u030E", "\x07=\x02\x02\u030A\u030B\x07U\x02\x02\u030B\u030D\x05", "\b\x05\x02\u030C\u030A\x03\x02\x02\x02\u030D\u0310\x03", "\x02\x02\x02\u030E\u030C\x03\x02\x02\x02\u030E\u030F\x03", "\x02\x02\x02\u030FU\x03\x02\x02\x02\u0310\u030E\x03", "\x02\x02\x02\u0311\u0312\x05X-\x02\u0312\u0313\x07\x05", "\x02\x02\u0313\u0314\x05\\/\x02\u0314W\x03\x02\x02\x02", "\u0315\u031A\x05Z.\x02\u0316\u0317\x07V\x02\x02\u0317\u0319", "\x05Z.\x02\u0318\u0316\x03\x02\x02\x02\u0319\u031C\x03", "\x02\x02\x02\u031A\u0318\x03\x02\x02\x02\u031A\u031B\x03", "\x02\x02\x02\u031BY\x03\x02\x02\x02\u031C\u031A\x03", "\x02\x02\x02\u031D\u031E\x07\n\x02\x02\u031E\u0320\x07", "D\x02\x02\u031F\u0321\x05d3\x02\u0320\u031F\x03\x02\x02", "\x02\u0320\u0321\x03\x02\x02\x02\u0321\u0322\x03\x02\x02", "\x02\u0322\u0323\x07E\x02\x02\u0323[\x03\x02\x02\x02", "\u0324\u0329\x05^0\x02\u0325\u0326\x07V\x02\x02\u0326\u0328", "\x05^0\x02\u0327\u0325\x03\x02\x02\x02\u0328\u032B\x03", "\x02\x02\x02\u0329\u0327\x03\x02\x02\x02\u0329\u032A\x03", "\x02\x02\x02\u032A]\x03\x02\x02\x02\u032B\u0329\x03", "\x02\x02\x02\u032C\u032D\x07=\x02\x02\u032D\u032F\x07", "F\x02\x02\u032E\u0330\x05`1\x02\u032F\u032E\x03\x02\x02", "\x02\u032F\u0330\x03\x02\x02\x02\u0330\u0331\x03\x02\x02", "\x02\u0331\u0334\x07G\x02\x02\u0332\u0334\x07=\x02\x02", "\u0333\u032C\x03\x02\x02\x02\u0333\u0332\x03\x02\x02\x02", "\u0334_\x03\x02\x02\x02\u0335\u033A\x05b2\x02\u0336\u0337", "\x07V\x02\x02\u0337\u0339\x05b2\x02\u0338\u0336\x03\x02", "\x02\x02\u0339\u033C\x03\x02\x02\x02\u033A\u0338\x03\x02", "\x02\x02\u033A\u033B\x03\x02\x02\x02\u033Ba\x03\x02", "\x02\x02\u033C\u033A\x03\x02\x02\x02\u033D\u033E\x07=", "\x02\x02\u033E\u033F\x07C\x02\x02\u033F\u0340\x07=\x02", "\x02\u0340c\x03\x02\x02\x02\u0341\u0342\x07=\x02\x02", "\u0342e\x03\x02\x02\x02Ukx\x7F\x97\x9E\xD4\xD8\xEA", "\xF0\xF5\xFB\u0106\u0108\u011B\u0124\u0134\u013E\u0144\u014E\u0154", "\u0156\u0160\u0166\u016D\u0178\u0185\u018B\u0199\u01A3\u01AE\u01B4\u01BE", "\u01C1\u01CD\u01D7\u01DD\u01E7\u01EC\u01F0\u01FA\u0200\u0205\u0209\u020B", "\u0217\u021F\u0222\u022A\u0235\u023F\u0245\u024F\u0257\u025E\u0262\u026A", "\u0274\u027A\u0289\u028D\u0295\u029C\u02A4\u02AB\u02B1\u02B8\u02BD\u02C0", "\u02C8\u02CF\u02D6\u02DC\u02E2\u02E6\u02F9\u0304\u030E\u031A\u0320\u0329", "\u032F\u0333\u033A"].join("");
    var atn = new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.atn.ATNDeserializer().deserialize(serializedATN);
    var decisionsToDFA = atn.decisionToState.map(function (ds, index) {
      return new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.dfa.DFA(ds, index);
    });
    var sharedContextCache = new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.PredictionContextCache();
    var literalNames = [null, null, null, "'by'", "'AS'", null, null, null, null, "'rex'", "'eval'", "'VIS'", "'dedup'", "'join'", "'table'", "'where'", "'lookup'", "'append'", "'nomv'", "'makemv'", "'mvcombine'", "'mvexpand'", "'stats'", "'docstats'", "'streamstats'", "'sort'", "'all'", "'merge'", "'top'", "'fetchlog'", "'index'", "'limit'", "'first'", "'last'", "'left'", "'inner'", "'on'", "'override'", "'exclude'", "'include'", "'random'", null, null, null, null, null, "'exec'", null, "'true'", "'false'", null, "'substr'", null, "'asc'", "'desc'", "'maxmatch'", null, null, null, null, null, "'+'", "'-'", null, "'/'", "'='", "'('", "')'", "'['", "']'", "'{'", "'}'", "':'", "'\"'", "'.'", "'@'", "'?'", null, "'&'", "'$'", "'^'", "'null'", "'[A-Za-z0-9_]+'", "'|'", "','"];
    var symbolicNames = [null, "NEWLINE", "WS", "BY", "AS", "SPAN", "STATSFUNCS", "STATSTWOPARAMFUNCS", "METRIC_METHOD", "REX", "EVAL", "VIS", "DEDUP", "JOIN", "TABLE", "WHERE", "LOOKUP", "APPEND", "NOMV", "MAKEMV", "MVCOMBINE", "MVEXPAND", "STATS", "DOCSTATS", "STREAMSTATS", "SORT", "ALL", "MERGE", "TOP", "FETCHLOG", "INDEX", "LIMIT", "FIRST", "LAST", "LEFT", "INNER", "ON", "OVERRIDE", "EXCLUDE", "INCLUDE", "NOPARAMEVAL", "ONEPARAMEVAL", "TWOPARAMEVAL", "STARTTIME", "ENDTIME", "OUTPUT", "EXEC", "CASE", "TRUE", "FALSE", "REGEX_STR", "SUBSTRING", "LOGICAL_OP", "ASC", "DESC", "MAXMATCH", "CONDITIONS", "INTLIT", "DECLIT", "STRLIT", "NUMBERS", "PLUS", "MINUS", "ASTERISK", "DIVISION", "ASSIGN", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LMIDDLE", "RMIDDLE", "COLON", "DOUBLE_QUOTE", "DOT", "ATTHERATE", "QUESTIONMARK", "STAR", "AND", "DOLLAR", "CAP", "NULL", "ID", "PIPE", "COMMA", "EXP", "UNSIGNED_INT", "ErrorCharacter"];
    var ruleNames = ["statement", "criterias", "expression", "joinexpression", "instruction", "methods", "dedup", "whereStatement", "lookupStatement", "appendStatement", "nomvStatement", "makemvStatement", "mvcombineStatement", "mvexpandStatement", "mvexpandoption", "statsStatement", "docStatsStatement", "streamStatsStatement", "statsfield", "sortStatement", "mergeStatement", "mergeoptions", "mergeoption", "values", "mergeFields", "topStatement", "topOption", "topFields", "sortlimit", "number", "unaryOperator", "unsignedNumber", "floatVal", "fetchlogQuery", "indexpattern", "join", "jointype", "maxmatchdoc", "overridefield", "table", "list", "subquery", "action", "metrics", "metric", "buckets", "bucket", "attributes", "attribute", "parameter"];

    function GrammarParser(input) {
      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.Parser.call(this, input);
      this._interp = new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
      this.ruleNames = ruleNames;
      this.literalNames = literalNames;
      this.symbolicNames = symbolicNames;
      return this;
    }

    GrammarParser.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.Parser.prototype);
    GrammarParser.prototype.constructor = GrammarParser;
    Object.defineProperty(GrammarParser.prototype, "atn", {
      get: function get() {
        return atn;
      }
    });
    GrammarParser.EOF = antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.Token.EOF;
    GrammarParser.NEWLINE = 1;
    GrammarParser.WS = 2;
    GrammarParser.BY = 3;
    GrammarParser.AS = 4;
    GrammarParser.SPAN = 5;
    GrammarParser.STATSFUNCS = 6;
    GrammarParser.STATSTWOPARAMFUNCS = 7;
    GrammarParser.METRIC_METHOD = 8;
    GrammarParser.REX = 9;
    GrammarParser.EVAL = 10;
    GrammarParser.VIS = 11;
    GrammarParser.DEDUP = 12;
    GrammarParser.JOIN = 13;
    GrammarParser.TABLE = 14;
    GrammarParser.WHERE = 15;
    GrammarParser.LOOKUP = 16;
    GrammarParser.APPEND = 17;
    GrammarParser.NOMV = 18;
    GrammarParser.MAKEMV = 19;
    GrammarParser.MVCOMBINE = 20;
    GrammarParser.MVEXPAND = 21;
    GrammarParser.STATS = 22;
    GrammarParser.DOCSTATS = 23;
    GrammarParser.STREAMSTATS = 24;
    GrammarParser.SORT = 25;
    GrammarParser.ALL = 26;
    GrammarParser.MERGE = 27;
    GrammarParser.TOP = 28;
    GrammarParser.FETCHLOG = 29;
    GrammarParser.INDEX = 30;
    GrammarParser.LIMIT = 31;
    GrammarParser.FIRST = 32;
    GrammarParser.LAST = 33;
    GrammarParser.LEFT = 34;
    GrammarParser.INNER = 35;
    GrammarParser.ON = 36;
    GrammarParser.OVERRIDE = 37;
    GrammarParser.EXCLUDE = 38;
    GrammarParser.INCLUDE = 39;
    GrammarParser.NOPARAMEVAL = 40;
    GrammarParser.ONEPARAMEVAL = 41;
    GrammarParser.TWOPARAMEVAL = 42;
    GrammarParser.STARTTIME = 43;
    GrammarParser.ENDTIME = 44;
    GrammarParser.OUTPUT = 45;
    GrammarParser.EXEC = 46;
    GrammarParser.CASE = 47;
    GrammarParser.TRUE = 48;
    GrammarParser.FALSE = 49;
    GrammarParser.REGEX_STR = 50;
    GrammarParser.SUBSTRING = 51;
    GrammarParser.LOGICAL_OP = 52;
    GrammarParser.ASC = 53;
    GrammarParser.DESC = 54;
    GrammarParser.MAXMATCH = 55;
    GrammarParser.CONDITIONS = 56;
    GrammarParser.INTLIT = 57;
    GrammarParser.DECLIT = 58;
    GrammarParser.STRLIT = 59;
    GrammarParser.NUMBERS = 60;
    GrammarParser.PLUS = 61;
    GrammarParser.MINUS = 62;
    GrammarParser.ASTERISK = 63;
    GrammarParser.DIVISION = 64;
    GrammarParser.ASSIGN = 65;
    GrammarParser.LPAREN = 66;
    GrammarParser.RPAREN = 67;
    GrammarParser.LBRACE = 68;
    GrammarParser.RBRACE = 69;
    GrammarParser.LMIDDLE = 70;
    GrammarParser.RMIDDLE = 71;
    GrammarParser.COLON = 72;
    GrammarParser.DOUBLE_QUOTE = 73;
    GrammarParser.DOT = 74;
    GrammarParser.ATTHERATE = 75;
    GrammarParser.QUESTIONMARK = 76;
    GrammarParser.STAR = 77;
    GrammarParser.AND = 78;
    GrammarParser.DOLLAR = 79;
    GrammarParser.CAP = 80;
    GrammarParser.NULL = 81;
    GrammarParser.ID = 82;
    GrammarParser.PIPE = 83;
    GrammarParser.COMMA = 84;
    GrammarParser.EXP = 85;
    GrammarParser.UNSIGNED_INT = 86;
    GrammarParser.ErrorCharacter = 87;
    GrammarParser.RULE_statement = 0;
    GrammarParser.RULE_criterias = 1;
    GrammarParser.RULE_expression = 2;
    GrammarParser.RULE_joinexpression = 3;
    GrammarParser.RULE_instruction = 4;
    GrammarParser.RULE_methods = 5;
    GrammarParser.RULE_dedup = 6;
    GrammarParser.RULE_whereStatement = 7;
    GrammarParser.RULE_lookupStatement = 8;
    GrammarParser.RULE_appendStatement = 9;
    GrammarParser.RULE_nomvStatement = 10;
    GrammarParser.RULE_makemvStatement = 11;
    GrammarParser.RULE_mvcombineStatement = 12;
    GrammarParser.RULE_mvexpandStatement = 13;
    GrammarParser.RULE_mvexpandoption = 14;
    GrammarParser.RULE_statsStatement = 15;
    GrammarParser.RULE_docStatsStatement = 16;
    GrammarParser.RULE_streamStatsStatement = 17;
    GrammarParser.RULE_statsfield = 18;
    GrammarParser.RULE_sortStatement = 19;
    GrammarParser.RULE_mergeStatement = 20;
    GrammarParser.RULE_mergeoptions = 21;
    GrammarParser.RULE_mergeoption = 22;
    GrammarParser.RULE_values = 23;
    GrammarParser.RULE_mergeFields = 24;
    GrammarParser.RULE_topStatement = 25;
    GrammarParser.RULE_topOption = 26;
    GrammarParser.RULE_topFields = 27;
    GrammarParser.RULE_sortlimit = 28;
    GrammarParser.RULE_number = 29;
    GrammarParser.RULE_unaryOperator = 30;
    GrammarParser.RULE_unsignedNumber = 31;
    GrammarParser.RULE_floatVal = 32;
    GrammarParser.RULE_fetchlogQuery = 33;
    GrammarParser.RULE_indexpattern = 34;
    GrammarParser.RULE_join = 35;
    GrammarParser.RULE_jointype = 36;
    GrammarParser.RULE_maxmatchdoc = 37;
    GrammarParser.RULE_overridefield = 38;
    GrammarParser.RULE_table = 39;
    GrammarParser.RULE_list = 40;
    GrammarParser.RULE_subquery = 41;
    GrammarParser.RULE_action = 42;
    GrammarParser.RULE_metrics = 43;
    GrammarParser.RULE_metric = 44;
    GrammarParser.RULE_buckets = 45;
    GrammarParser.RULE_bucket = 46;
    GrammarParser.RULE_attributes = 47;
    GrammarParser.RULE_attribute = 48;
    GrammarParser.RULE_parameter = 49;

    function StatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_statement;
      return this;
    }

    StatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    StatementContext.prototype.constructor = StatementContext;

    StatementContext.prototype.criterias = function () {
      return this.getTypedRuleContext(CriteriasContext, 0);
    };

    StatementContext.prototype.PIPE = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.PIPE);
      } else {
        return this.getToken(GrammarParser.PIPE, i);
      }
    };

    StatementContext.prototype.expression = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(ExpressionContext);
      } else {
        return this.getTypedRuleContext(ExpressionContext, i);
      }
    };

    StatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterStatement(this);
      }
    };

    StatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitStatement(this);
      }
    };

    StatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.StatementContext = StatementContext;

    GrammarParser.prototype.statement = function () {
      var localctx = new StatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 0, GrammarParser.RULE_statement);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 100;
        this.criterias(0);
        this.state = 105;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.PIPE) {
          this.state = 101;
          this.match(GrammarParser.PIPE);
          this.state = 102;
          this.expression();
          this.state = 107;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function CriteriasContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_criterias;
      return this;
    }

    CriteriasContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    CriteriasContext.prototype.constructor = CriteriasContext;

    CriteriasContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    CriteriasContext.prototype.EXP = function () {
      return this.getToken(GrammarParser.EXP, 0);
    };

    CriteriasContext.prototype.ASTERISK = function () {
      return this.getToken(GrammarParser.ASTERISK, 0);
    };

    CriteriasContext.prototype.COLON = function () {
      return this.getToken(GrammarParser.COLON, 0);
    };

    CriteriasContext.prototype.criterias = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(CriteriasContext);
      } else {
        return this.getTypedRuleContext(CriteriasContext, i);
      }
    };

    CriteriasContext.prototype.LOGICAL_OP = function () {
      return this.getToken(GrammarParser.LOGICAL_OP, 0);
    };

    CriteriasContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterCriterias(this);
      }
    };

    CriteriasContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitCriterias(this);
      }
    };

    CriteriasContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitCriterias(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.prototype.criterias = function (_p) {
      if (_p === undefined) {
        _p = 0;
      }

      var _parentctx = this._ctx;
      var _parentState = this.state;
      var localctx = new CriteriasContext(this, this._ctx, _parentState);
      var _prevctx = localctx;
      var _startState = 2;
      this.enterRecursionRule(localctx, 2, GrammarParser.RULE_criterias, _p);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 118;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 1, this._ctx);

        switch (la_) {
          case 1:
            this.state = 109;
            this.match(GrammarParser.STRLIT);
            break;

          case 2:
            this.state = 110;
            this.match(GrammarParser.EXP);
            break;

          case 3:
            this.state = 111;
            this.match(GrammarParser.ASTERISK);
            break;

          case 4:
            this.state = 112;
            this.match(GrammarParser.STRLIT);
            this.state = 113;
            this.match(GrammarParser.COLON);
            this.state = 114;
            this.match(GrammarParser.STRLIT);
            break;

          case 5:
            this.state = 115;
            this.match(GrammarParser.STRLIT);
            this.state = 116;
            this.match(GrammarParser.COLON);
            this.state = 117;
            this.match(GrammarParser.EXP);
            break;
        }

        this._ctx.stop = this._input.LT(-1);
        this.state = 125;

        this._errHandler.sync(this);

        var _alt = this._interp.adaptivePredict(this._input, 2, this._ctx);

        while (_alt != 2 && _alt != antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.atn.ATN.INVALID_ALT_NUMBER) {
          if (_alt === 1) {
            if (this._parseListeners !== null) {
              this.triggerExitRuleEvent();
            }

            _prevctx = localctx;
            localctx = new CriteriasContext(this, _parentctx, _parentState);
            this.pushNewRecursionContext(localctx, _startState, GrammarParser.RULE_criterias);
            this.state = 120;

            if (!this.precpred(this._ctx, 6)) {
              throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.FailedPredicateException(this, "this.precpred(this._ctx, 6)");
            }

            this.state = 121;
            this.match(GrammarParser.LOGICAL_OP);
            this.state = 122;
            this.criterias(7);
          }

          this.state = 127;

          this._errHandler.sync(this);

          _alt = this._interp.adaptivePredict(this._input, 2, this._ctx);
        }
      } catch (error) {
        if (error instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = error;

          this._errHandler.reportError(this, error);

          this._errHandler.recover(this, error);
        } else {
          throw error;
        }
      } finally {
        this.unrollRecursionContexts(_parentctx);
      }

      return localctx;
    };

    function ExpressionContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_expression;
      return this;
    }

    ExpressionContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    ExpressionContext.prototype.constructor = ExpressionContext;

    ExpressionContext.prototype.EVAL = function () {
      return this.getToken(GrammarParser.EVAL, 0);
    };

    ExpressionContext.prototype.methods = function () {
      return this.getTypedRuleContext(MethodsContext, 0);
    };

    ExpressionContext.prototype.REX = function () {
      return this.getToken(GrammarParser.REX, 0);
    };

    ExpressionContext.prototype.instruction = function () {
      return this.getTypedRuleContext(InstructionContext, 0);
    };

    ExpressionContext.prototype.dedup = function () {
      return this.getTypedRuleContext(DedupContext, 0);
    };

    ExpressionContext.prototype.join = function () {
      return this.getTypedRuleContext(JoinContext, 0);
    };

    ExpressionContext.prototype.table = function () {
      return this.getTypedRuleContext(TableContext, 0);
    };

    ExpressionContext.prototype.whereStatement = function () {
      return this.getTypedRuleContext(WhereStatementContext, 0);
    };

    ExpressionContext.prototype.lookupStatement = function () {
      return this.getTypedRuleContext(LookupStatementContext, 0);
    };

    ExpressionContext.prototype.nomvStatement = function () {
      return this.getTypedRuleContext(NomvStatementContext, 0);
    };

    ExpressionContext.prototype.appendStatement = function () {
      return this.getTypedRuleContext(AppendStatementContext, 0);
    };

    ExpressionContext.prototype.makemvStatement = function () {
      return this.getTypedRuleContext(MakemvStatementContext, 0);
    };

    ExpressionContext.prototype.mvexpandStatement = function () {
      return this.getTypedRuleContext(MvexpandStatementContext, 0);
    };

    ExpressionContext.prototype.mvcombineStatement = function () {
      return this.getTypedRuleContext(MvcombineStatementContext, 0);
    };

    ExpressionContext.prototype.statsStatement = function () {
      return this.getTypedRuleContext(StatsStatementContext, 0);
    };

    ExpressionContext.prototype.docStatsStatement = function () {
      return this.getTypedRuleContext(DocStatsStatementContext, 0);
    };

    ExpressionContext.prototype.streamStatsStatement = function () {
      return this.getTypedRuleContext(StreamStatsStatementContext, 0);
    };

    ExpressionContext.prototype.sortStatement = function () {
      return this.getTypedRuleContext(SortStatementContext, 0);
    };

    ExpressionContext.prototype.mergeStatement = function () {
      return this.getTypedRuleContext(MergeStatementContext, 0);
    };

    ExpressionContext.prototype.topStatement = function () {
      return this.getTypedRuleContext(TopStatementContext, 0);
    };

    ExpressionContext.prototype.fetchlogQuery = function () {
      return this.getTypedRuleContext(FetchlogQueryContext, 0);
    };

    ExpressionContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterExpression(this);
      }
    };

    ExpressionContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitExpression(this);
      }
    };

    ExpressionContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitExpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.ExpressionContext = ExpressionContext;

    GrammarParser.prototype.expression = function () {
      var localctx = new ExpressionContext(this, this._ctx, this.state);
      this.enterRule(localctx, 4, GrammarParser.RULE_expression);

      try {
        this.state = 149;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 3, this._ctx);

        switch (la_) {
          case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 128;
            this.match(GrammarParser.EVAL);
            this.state = 129;
            this.methods();
            break;

          case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 130;
            this.match(GrammarParser.REX);
            this.state = 131;
            this.instruction();
            break;

          case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 132;
            this.dedup();
            break;

          case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 133;
            this.join();
            break;

          case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 134;
            this.table();
            break;

          case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 135;
            this.whereStatement();
            break;

          case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 136;
            this.lookupStatement();
            break;

          case 8:
            this.enterOuterAlt(localctx, 8);
            this.state = 137;
            this.nomvStatement();
            break;

          case 9:
            this.enterOuterAlt(localctx, 9);
            this.state = 138;
            this.appendStatement();
            break;

          case 10:
            this.enterOuterAlt(localctx, 10);
            this.state = 139;
            this.makemvStatement();
            break;

          case 11:
            this.enterOuterAlt(localctx, 11);
            this.state = 140;
            this.mvexpandStatement();
            break;

          case 12:
            this.enterOuterAlt(localctx, 12);
            this.state = 141;
            this.mvcombineStatement();
            break;

          case 13:
            this.enterOuterAlt(localctx, 13);
            this.state = 142;
            this.statsStatement();
            break;

          case 14:
            this.enterOuterAlt(localctx, 14);
            this.state = 143;
            this.docStatsStatement();
            break;

          case 15:
            this.enterOuterAlt(localctx, 15);
            this.state = 144;
            this.streamStatsStatement();
            break;

          case 16:
            this.enterOuterAlt(localctx, 16);
            this.state = 145;
            this.sortStatement();
            break;

          case 17:
            this.enterOuterAlt(localctx, 17);
            this.state = 146;
            this.mergeStatement();
            break;

          case 18:
            this.enterOuterAlt(localctx, 18);
            this.state = 147;
            this.topStatement();
            break;

          case 19:
            this.enterOuterAlt(localctx, 19);
            this.state = 148;
            this.fetchlogQuery();
            break;
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function JoinexpressionContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_joinexpression;
      return this;
    }

    JoinexpressionContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    JoinexpressionContext.prototype.constructor = JoinexpressionContext;

    JoinexpressionContext.prototype.EVAL = function () {
      return this.getToken(GrammarParser.EVAL, 0);
    };

    JoinexpressionContext.prototype.methods = function () {
      return this.getTypedRuleContext(MethodsContext, 0);
    };

    JoinexpressionContext.prototype.REX = function () {
      return this.getToken(GrammarParser.REX, 0);
    };

    JoinexpressionContext.prototype.instruction = function () {
      return this.getTypedRuleContext(InstructionContext, 0);
    };

    JoinexpressionContext.prototype.dedup = function () {
      return this.getTypedRuleContext(DedupContext, 0);
    };

    JoinexpressionContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterJoinexpression(this);
      }
    };

    JoinexpressionContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitJoinexpression(this);
      }
    };

    JoinexpressionContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitJoinexpression(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.JoinexpressionContext = JoinexpressionContext;

    GrammarParser.prototype.joinexpression = function () {
      var localctx = new JoinexpressionContext(this, this._ctx, this.state);
      this.enterRule(localctx, 6, GrammarParser.RULE_joinexpression);

      try {
        this.state = 156;

        this._errHandler.sync(this);

        switch (this._input.LA(1)) {
          case GrammarParser.EVAL:
            this.enterOuterAlt(localctx, 1);
            this.state = 151;
            this.match(GrammarParser.EVAL);
            this.state = 152;
            this.methods();
            break;

          case GrammarParser.REX:
            this.enterOuterAlt(localctx, 2);
            this.state = 153;
            this.match(GrammarParser.REX);
            this.state = 154;
            this.instruction();
            break;

          case GrammarParser.DEDUP:
            this.enterOuterAlt(localctx, 3);
            this.state = 155;
            this.dedup();
            break;

          default:
            throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function InstructionContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_instruction;
      return this;
    }

    InstructionContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    InstructionContext.prototype.constructor = InstructionContext;

    InstructionContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    InstructionContext.prototype.ASSIGN = function () {
      return this.getToken(GrammarParser.ASSIGN, 0);
    };

    InstructionContext.prototype.EXP = function () {
      return this.getToken(GrammarParser.EXP, 0);
    };

    InstructionContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterInstruction(this);
      }
    };

    InstructionContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitInstruction(this);
      }
    };

    InstructionContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitInstruction(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.InstructionContext = InstructionContext;

    GrammarParser.prototype.instruction = function () {
      var localctx = new InstructionContext(this, this._ctx, this.state);
      this.enterRule(localctx, 8, GrammarParser.RULE_instruction);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 158;
        this.match(GrammarParser.STRLIT);
        this.state = 159;
        this.match(GrammarParser.ASSIGN);
        this.state = 160;
        this.match(GrammarParser.EXP);
        this.state = 161;
        this.match(GrammarParser.STRLIT);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MethodsContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_methods;
      return this;
    }

    MethodsContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MethodsContext.prototype.constructor = MethodsContext;

    MethodsContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    MethodsContext.prototype.ASSIGN = function () {
      return this.getToken(GrammarParser.ASSIGN, 0);
    };

    MethodsContext.prototype.NOPARAMEVAL = function () {
      return this.getToken(GrammarParser.NOPARAMEVAL, 0);
    };

    MethodsContext.prototype.LPAREN = function () {
      return this.getToken(GrammarParser.LPAREN, 0);
    };

    MethodsContext.prototype.RPAREN = function () {
      return this.getToken(GrammarParser.RPAREN, 0);
    };

    MethodsContext.prototype.EXEC = function () {
      return this.getToken(GrammarParser.EXEC, 0);
    };

    MethodsContext.prototype.EXP = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.EXP);
      } else {
        return this.getToken(GrammarParser.EXP, i);
      }
    };

    MethodsContext.prototype.ONEPARAMEVAL = function () {
      return this.getToken(GrammarParser.ONEPARAMEVAL, 0);
    };

    MethodsContext.prototype.INTLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.INTLIT);
      } else {
        return this.getToken(GrammarParser.INTLIT, i);
      }
    };

    MethodsContext.prototype.DECLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.DECLIT);
      } else {
        return this.getToken(GrammarParser.DECLIT, i);
      }
    };

    MethodsContext.prototype.TWOPARAMEVAL = function () {
      return this.getToken(GrammarParser.TWOPARAMEVAL, 0);
    };

    MethodsContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    MethodsContext.prototype.CASE = function () {
      return this.getToken(GrammarParser.CASE, 0);
    };

    MethodsContext.prototype.CONDITIONS = function () {
      return this.getToken(GrammarParser.CONDITIONS, 0);
    };

    MethodsContext.prototype.SUBSTRING = function () {
      return this.getToken(GrammarParser.SUBSTRING, 0);
    };

    MethodsContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMethods(this);
      }
    };

    MethodsContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMethods(this);
      }
    };

    MethodsContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMethods(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MethodsContext = MethodsContext;

    GrammarParser.prototype.methods = function () {
      var localctx = new MethodsContext(this, this._ctx, this.state);
      this.enterRule(localctx, 10, GrammarParser.RULE_methods);
      var _la = 0; // Token type

      try {
        this.state = 210;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 5, this._ctx);

        switch (la_) {
          case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 163;
            this.match(GrammarParser.STRLIT);
            this.state = 164;
            this.match(GrammarParser.ASSIGN);
            this.state = 165;
            this.match(GrammarParser.NOPARAMEVAL);
            this.state = 166;
            this.match(GrammarParser.LPAREN);
            this.state = 167;
            this.match(GrammarParser.RPAREN);
            break;

          case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 168;
            this.match(GrammarParser.STRLIT);
            this.state = 169;
            this.match(GrammarParser.ASSIGN);
            this.state = 170;
            this.match(GrammarParser.EXEC);
            this.state = 171;
            this.match(GrammarParser.LPAREN);
            this.state = 172;
            this.match(GrammarParser.EXP);
            this.state = 173;
            this.match(GrammarParser.RPAREN);
            break;

          case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 174;
            this.match(GrammarParser.STRLIT);
            this.state = 175;
            this.match(GrammarParser.ASSIGN);
            this.state = 176;
            this.match(GrammarParser.ONEPARAMEVAL);
            this.state = 177;
            this.match(GrammarParser.LPAREN);
            this.state = 178;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 179;
            this.match(GrammarParser.RPAREN);
            break;

          case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 180;
            this.match(GrammarParser.STRLIT);
            this.state = 181;
            this.match(GrammarParser.ASSIGN);
            this.state = 182;
            this.match(GrammarParser.TWOPARAMEVAL);
            this.state = 183;
            this.match(GrammarParser.LPAREN);
            this.state = 184;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 185;
            this.match(GrammarParser.COMMA);
            this.state = 186;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 187;
            this.match(GrammarParser.RPAREN);
            break;

          case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 188;
            this.match(GrammarParser.STRLIT);
            this.state = 189;
            this.match(GrammarParser.ASSIGN);
            this.state = 190;
            this.match(GrammarParser.CASE);
            this.state = 191;
            this.match(GrammarParser.LPAREN);
            this.state = 192;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 193;
            this.match(GrammarParser.CONDITIONS);
            this.state = 194;
            this.match(GrammarParser.EXP);
            this.state = 195;
            this.match(GrammarParser.COMMA);
            this.state = 196;
            this.match(GrammarParser.EXP);
            this.state = 197;
            this.match(GrammarParser.COMMA);
            this.state = 198;
            this.match(GrammarParser.EXP);
            this.state = 199;
            this.match(GrammarParser.RPAREN);
            break;

          case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 200;
            this.match(GrammarParser.STRLIT);
            this.state = 201;
            this.match(GrammarParser.ASSIGN);
            this.state = 202;
            this.match(GrammarParser.SUBSTRING);
            this.state = 203;
            this.match(GrammarParser.LPAREN);
            this.state = 204;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 205;
            this.match(GrammarParser.COMMA);
            this.state = 206;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 207;
            this.match(GrammarParser.COMMA);
            this.state = 208;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 209;
            this.match(GrammarParser.RPAREN);
            break;
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function DedupContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_dedup;
      return this;
    }

    DedupContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    DedupContext.prototype.constructor = DedupContext;

    DedupContext.prototype.DEDUP = function () {
      return this.getToken(GrammarParser.DEDUP, 0);
    };

    DedupContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    DedupContext.prototype.PIPE = function () {
      return this.getToken(GrammarParser.PIPE, 0);
    };

    DedupContext.prototype.expression = function () {
      return this.getTypedRuleContext(ExpressionContext, 0);
    };

    DedupContext.prototype.INTLIT = function () {
      return this.getToken(GrammarParser.INTLIT, 0);
    };

    DedupContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterDedup(this);
      }
    };

    DedupContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitDedup(this);
      }
    };

    DedupContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitDedup(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.DedupContext = DedupContext;

    GrammarParser.prototype.dedup = function () {
      var localctx = new DedupContext(this, this._ctx, this.state);
      this.enterRule(localctx, 12, GrammarParser.RULE_dedup);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 212;
        this.match(GrammarParser.DEDUP);
        this.state = 214;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        if (_la === GrammarParser.INTLIT) {
          this.state = 213;
          this.match(GrammarParser.INTLIT);
        }

        this.state = 216;
        this.match(GrammarParser.STRLIT);
        this.state = 217;
        this.match(GrammarParser.PIPE);
        this.state = 218;
        this.expression();
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function WhereStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_whereStatement;
      return this;
    }

    WhereStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    WhereStatementContext.prototype.constructor = WhereStatementContext;

    WhereStatementContext.prototype.WHERE = function () {
      return this.getToken(GrammarParser.WHERE, 0);
    };

    WhereStatementContext.prototype.CONDITIONS = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.CONDITIONS);
      } else {
        return this.getToken(GrammarParser.CONDITIONS, i);
      }
    };

    WhereStatementContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    WhereStatementContext.prototype.STARTTIME = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STARTTIME);
      } else {
        return this.getToken(GrammarParser.STARTTIME, i);
      }
    };

    WhereStatementContext.prototype.INTLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.INTLIT);
      } else {
        return this.getToken(GrammarParser.INTLIT, i);
      }
    };

    WhereStatementContext.prototype.DECLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.DECLIT);
      } else {
        return this.getToken(GrammarParser.DECLIT, i);
      }
    };

    WhereStatementContext.prototype.EXP = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.EXP);
      } else {
        return this.getToken(GrammarParser.EXP, i);
      }
    };

    WhereStatementContext.prototype.LOGICAL_OP = function () {
      return this.getToken(GrammarParser.LOGICAL_OP, 0);
    };

    WhereStatementContext.prototype.ENDTIME = function () {
      return this.getToken(GrammarParser.ENDTIME, 0);
    };

    WhereStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterWhereStatement(this);
      }
    };

    WhereStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitWhereStatement(this);
      }
    };

    WhereStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitWhereStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.WhereStatementContext = WhereStatementContext;

    GrammarParser.prototype.whereStatement = function () {
      var localctx = new WhereStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 14, GrammarParser.RULE_whereStatement);
      var _la = 0; // Token type

      try {
        this.state = 232;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 7, this._ctx);

        switch (la_) {
          case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 220;
            this.match(GrammarParser.WHERE);
            this.state = 221;
            _la = this._input.LA(1);

            if (!(_la === GrammarParser.STARTTIME || _la === GrammarParser.STRLIT)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 222;
            this.match(GrammarParser.CONDITIONS);
            this.state = 223;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57 | 1 << GrammarParser.EXP - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            break;

          case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 224;
            this.match(GrammarParser.WHERE);
            this.state = 225;
            _la = this._input.LA(1);

            if (!(_la === GrammarParser.STARTTIME || _la === GrammarParser.STRLIT)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 226;
            this.match(GrammarParser.CONDITIONS);
            this.state = 227;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57 | 1 << GrammarParser.EXP - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 228;
            this.match(GrammarParser.LOGICAL_OP);
            this.state = 229;
            _la = this._input.LA(1);

            if (!((_la - 43 & ~0x1f) == 0 && (1 << _la - 43 & (1 << GrammarParser.STARTTIME - 43 | 1 << GrammarParser.ENDTIME - 43 | 1 << GrammarParser.STRLIT - 43)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            this.state = 230;
            this.match(GrammarParser.CONDITIONS);
            this.state = 231;
            _la = this._input.LA(1);

            if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57 | 1 << GrammarParser.EXP - 57)) !== 0)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            break;
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function LookupStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_lookupStatement;
      return this;
    }

    LookupStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    LookupStatementContext.prototype.constructor = LookupStatementContext;

    LookupStatementContext.prototype.LOOKUP = function () {
      return this.getToken(GrammarParser.LOOKUP, 0);
    };

    LookupStatementContext.prototype.OUTPUT = function () {
      return this.getToken(GrammarParser.OUTPUT, 0);
    };

    LookupStatementContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    LookupStatementContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    LookupStatementContext.prototype.DOT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.DOT);
      } else {
        return this.getToken(GrammarParser.DOT, i);
      }
    };

    LookupStatementContext.prototype.ATTHERATE = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.ATTHERATE);
      } else {
        return this.getToken(GrammarParser.ATTHERATE, i);
      }
    };

    LookupStatementContext.prototype.QUESTIONMARK = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.QUESTIONMARK);
      } else {
        return this.getToken(GrammarParser.QUESTIONMARK, i);
      }
    };

    LookupStatementContext.prototype.STAR = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STAR);
      } else {
        return this.getToken(GrammarParser.STAR, i);
      }
    };

    LookupStatementContext.prototype.DOLLAR = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.DOLLAR);
      } else {
        return this.getToken(GrammarParser.DOLLAR, i);
      }
    };

    LookupStatementContext.prototype.CAP = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.CAP);
      } else {
        return this.getToken(GrammarParser.CAP, i);
      }
    };

    LookupStatementContext.prototype.AND = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.AND);
      } else {
        return this.getToken(GrammarParser.AND, i);
      }
    };

    LookupStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterLookupStatement(this);
      }
    };

    LookupStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitLookupStatement(this);
      }
    };

    LookupStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitLookupStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.LookupStatementContext = LookupStatementContext;

    GrammarParser.prototype.lookupStatement = function () {
      var localctx = new LookupStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 16, GrammarParser.RULE_lookupStatement);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 234;
        this.match(GrammarParser.LOOKUP);
        this.state = 236;

        this._errHandler.sync(this);

        var _alt = 1;

        do {
          switch (_alt) {
            case 1:
              this.state = 235;
              _la = this._input.LA(1);

              if (!((_la - 59 & ~0x1f) == 0 && (1 << _la - 59 & (1 << GrammarParser.STRLIT - 59 | 1 << GrammarParser.DOT - 59 | 1 << GrammarParser.ATTHERATE - 59 | 1 << GrammarParser.QUESTIONMARK - 59 | 1 << GrammarParser.STAR - 59 | 1 << GrammarParser.AND - 59 | 1 << GrammarParser.DOLLAR - 59 | 1 << GrammarParser.CAP - 59)) !== 0)) {
                this._errHandler.recoverInline(this);
              } else {
                this._errHandler.reportMatch(this);

                this.consume();
              }

              break;

            default:
              throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
          }

          this.state = 238;

          this._errHandler.sync(this);

          _alt = this._interp.adaptivePredict(this._input, 8, this._ctx);
        } while (_alt != 2 && _alt != antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.atn.ATN.INVALID_ALT_NUMBER);

        this.state = 241;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        do {
          this.state = 240;
          _la = this._input.LA(1);

          if (!((_la - 59 & ~0x1f) == 0 && (1 << _la - 59 & (1 << GrammarParser.STRLIT - 59 | 1 << GrammarParser.DOT - 59 | 1 << GrammarParser.ATTHERATE - 59 | 1 << GrammarParser.QUESTIONMARK - 59 | 1 << GrammarParser.STAR - 59 | 1 << GrammarParser.AND - 59 | 1 << GrammarParser.DOLLAR - 59 | 1 << GrammarParser.CAP - 59)) !== 0)) {
            this._errHandler.recoverInline(this);
          } else {
            this._errHandler.reportMatch(this);

            this.consume();
          }

          this.state = 243;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        } while ((_la - 59 & ~0x1f) == 0 && (1 << _la - 59 & (1 << GrammarParser.STRLIT - 59 | 1 << GrammarParser.DOT - 59 | 1 << GrammarParser.ATTHERATE - 59 | 1 << GrammarParser.QUESTIONMARK - 59 | 1 << GrammarParser.STAR - 59 | 1 << GrammarParser.AND - 59 | 1 << GrammarParser.DOLLAR - 59 | 1 << GrammarParser.CAP - 59)) !== 0);

        this.state = 245;
        this.match(GrammarParser.OUTPUT);
        this.state = 247;

        this._errHandler.sync(this);

        var _alt = 1;

        do {
          switch (_alt) {
            case 1:
              this.state = 246;
              _la = this._input.LA(1);

              if (!((_la - 59 & ~0x1f) == 0 && (1 << _la - 59 & (1 << GrammarParser.STRLIT - 59 | 1 << GrammarParser.DOT - 59 | 1 << GrammarParser.ATTHERATE - 59 | 1 << GrammarParser.QUESTIONMARK - 59 | 1 << GrammarParser.STAR - 59 | 1 << GrammarParser.AND - 59 | 1 << GrammarParser.DOLLAR - 59 | 1 << GrammarParser.CAP - 59)) !== 0)) {
                this._errHandler.recoverInline(this);
              } else {
                this._errHandler.reportMatch(this);

                this.consume();
              }

              break;

            default:
              throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
          }

          this.state = 249;

          this._errHandler.sync(this);

          _alt = this._interp.adaptivePredict(this._input, 10, this._ctx);
        } while (_alt != 2 && _alt != antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.atn.ATN.INVALID_ALT_NUMBER);

        this.state = 262;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while ((_la - 74 & ~0x1f) == 0 && (1 << _la - 74 & (1 << GrammarParser.DOT - 74 | 1 << GrammarParser.ATTHERATE - 74 | 1 << GrammarParser.QUESTIONMARK - 74 | 1 << GrammarParser.STAR - 74 | 1 << GrammarParser.AND - 74 | 1 << GrammarParser.DOLLAR - 74 | 1 << GrammarParser.CAP - 74 | 1 << GrammarParser.COMMA - 74)) !== 0) {
          this.state = 260;

          this._errHandler.sync(this);

          switch (this._input.LA(1)) {
            case GrammarParser.COMMA:
              this.state = 251;
              this.match(GrammarParser.COMMA);
              this.state = 252;
              this.match(GrammarParser.STRLIT);
              break;

            case GrammarParser.DOT:
              this.state = 253;
              this.match(GrammarParser.DOT);
              break;

            case GrammarParser.ATTHERATE:
              this.state = 254;
              this.match(GrammarParser.ATTHERATE);
              break;

            case GrammarParser.QUESTIONMARK:
              this.state = 255;
              this.match(GrammarParser.QUESTIONMARK);
              break;

            case GrammarParser.STAR:
              this.state = 256;
              this.match(GrammarParser.STAR);
              break;

            case GrammarParser.DOLLAR:
              this.state = 257;
              this.match(GrammarParser.DOLLAR);
              break;

            case GrammarParser.CAP:
              this.state = 258;
              this.match(GrammarParser.CAP);
              break;

            case GrammarParser.AND:
              this.state = 259;
              this.match(GrammarParser.AND);
              break;

            default:
              throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
          }

          this.state = 264;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function AppendStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_appendStatement;
      return this;
    }

    AppendStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    AppendStatementContext.prototype.constructor = AppendStatementContext;

    AppendStatementContext.prototype.APPEND = function () {
      return this.getToken(GrammarParser.APPEND, 0);
    };

    AppendStatementContext.prototype.LBRACE = function () {
      return this.getToken(GrammarParser.LBRACE, 0);
    };

    AppendStatementContext.prototype.statement = function () {
      return this.getTypedRuleContext(StatementContext, 0);
    };

    AppendStatementContext.prototype.RBRACE = function () {
      return this.getToken(GrammarParser.RBRACE, 0);
    };

    AppendStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterAppendStatement(this);
      }
    };

    AppendStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitAppendStatement(this);
      }
    };

    AppendStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitAppendStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.AppendStatementContext = AppendStatementContext;

    GrammarParser.prototype.appendStatement = function () {
      var localctx = new AppendStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 18, GrammarParser.RULE_appendStatement);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 265;
        this.match(GrammarParser.APPEND);
        this.state = 266;
        this.match(GrammarParser.LBRACE);
        this.state = 267;
        this.statement();
        this.state = 268;
        this.match(GrammarParser.RBRACE);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function NomvStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_nomvStatement;
      return this;
    }

    NomvStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    NomvStatementContext.prototype.constructor = NomvStatementContext;

    NomvStatementContext.prototype.NOMV = function () {
      return this.getToken(GrammarParser.NOMV, 0);
    };

    NomvStatementContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    NomvStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterNomvStatement(this);
      }
    };

    NomvStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitNomvStatement(this);
      }
    };

    NomvStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitNomvStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.NomvStatementContext = NomvStatementContext;

    GrammarParser.prototype.nomvStatement = function () {
      var localctx = new NomvStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 20, GrammarParser.RULE_nomvStatement);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 270;
        this.match(GrammarParser.NOMV);
        this.state = 271;
        this.match(GrammarParser.STRLIT);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MakemvStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_makemvStatement;
      return this;
    }

    MakemvStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MakemvStatementContext.prototype.constructor = MakemvStatementContext;

    MakemvStatementContext.prototype.MAKEMV = function () {
      return this.getToken(GrammarParser.MAKEMV, 0);
    };

    MakemvStatementContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    MakemvStatementContext.prototype.ASSIGN = function () {
      return this.getToken(GrammarParser.ASSIGN, 0);
    };

    MakemvStatementContext.prototype.EXP = function () {
      return this.getToken(GrammarParser.EXP, 0);
    };

    MakemvStatementContext.prototype.REGEX_STR = function () {
      return this.getToken(GrammarParser.REGEX_STR, 0);
    };

    MakemvStatementContext.prototype.TRUE = function () {
      return this.getToken(GrammarParser.TRUE, 0);
    };

    MakemvStatementContext.prototype.FALSE = function () {
      return this.getToken(GrammarParser.FALSE, 0);
    };

    MakemvStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMakemvStatement(this);
      }
    };

    MakemvStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMakemvStatement(this);
      }
    };

    MakemvStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMakemvStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MakemvStatementContext = MakemvStatementContext;

    GrammarParser.prototype.makemvStatement = function () {
      var localctx = new MakemvStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 22, GrammarParser.RULE_makemvStatement);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 273;
        this.match(GrammarParser.MAKEMV);
        this.state = 274;
        this.match(GrammarParser.STRLIT);
        this.state = 275;
        this.match(GrammarParser.ASSIGN);
        this.state = 276;
        _la = this._input.LA(1);

        if (!((_la - 48 & ~0x1f) == 0 && (1 << _la - 48 & (1 << GrammarParser.TRUE - 48 | 1 << GrammarParser.FALSE - 48 | 1 << GrammarParser.REGEX_STR - 48)) !== 0 || _la === GrammarParser.EXP)) {
          this._errHandler.recoverInline(this);
        } else {
          this._errHandler.reportMatch(this);

          this.consume();
        }

        this.state = 281;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.STRLIT) {
          this.state = 278;
          this.match(GrammarParser.STRLIT);
          this.state = 283;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MvcombineStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_mvcombineStatement;
      return this;
    }

    MvcombineStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MvcombineStatementContext.prototype.constructor = MvcombineStatementContext;

    MvcombineStatementContext.prototype.MVCOMBINE = function () {
      return this.getToken(GrammarParser.MVCOMBINE, 0);
    };

    MvcombineStatementContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    MvcombineStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMvcombineStatement(this);
      }
    };

    MvcombineStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMvcombineStatement(this);
      }
    };

    MvcombineStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMvcombineStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MvcombineStatementContext = MvcombineStatementContext;

    GrammarParser.prototype.mvcombineStatement = function () {
      var localctx = new MvcombineStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 24, GrammarParser.RULE_mvcombineStatement);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 284;
        this.match(GrammarParser.MVCOMBINE);
        this.state = 285;
        this.match(GrammarParser.STRLIT);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MvexpandStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_mvexpandStatement;
      return this;
    }

    MvexpandStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MvexpandStatementContext.prototype.constructor = MvexpandStatementContext;

    MvexpandStatementContext.prototype.MVEXPAND = function () {
      return this.getToken(GrammarParser.MVEXPAND, 0);
    };

    MvexpandStatementContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    MvexpandStatementContext.prototype.mvexpandoption = function () {
      return this.getTypedRuleContext(MvexpandoptionContext, 0);
    };

    MvexpandStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMvexpandStatement(this);
      }
    };

    MvexpandStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMvexpandStatement(this);
      }
    };

    MvexpandStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMvexpandStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MvexpandStatementContext = MvexpandStatementContext;

    GrammarParser.prototype.mvexpandStatement = function () {
      var localctx = new MvexpandStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 26, GrammarParser.RULE_mvexpandStatement);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 287;
        this.match(GrammarParser.MVEXPAND);
        this.state = 288;
        this.match(GrammarParser.STRLIT);
        this.state = 290;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        if (_la === GrammarParser.STRLIT) {
          this.state = 289;
          this.mvexpandoption();
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MvexpandoptionContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_mvexpandoption;
      return this;
    }

    MvexpandoptionContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MvexpandoptionContext.prototype.constructor = MvexpandoptionContext;

    MvexpandoptionContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    MvexpandoptionContext.prototype.ASSIGN = function () {
      return this.getToken(GrammarParser.ASSIGN, 0);
    };

    MvexpandoptionContext.prototype.UNSIGNED_INT = function () {
      return this.getToken(GrammarParser.UNSIGNED_INT, 0);
    };

    MvexpandoptionContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMvexpandoption(this);
      }
    };

    MvexpandoptionContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMvexpandoption(this);
      }
    };

    MvexpandoptionContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMvexpandoption(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MvexpandoptionContext = MvexpandoptionContext;

    GrammarParser.prototype.mvexpandoption = function () {
      var localctx = new MvexpandoptionContext(this, this._ctx, this.state);
      this.enterRule(localctx, 28, GrammarParser.RULE_mvexpandoption);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 292;
        this.match(GrammarParser.STRLIT);
        this.state = 293;
        this.match(GrammarParser.ASSIGN);
        this.state = 294;
        this.match(GrammarParser.UNSIGNED_INT);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function StatsStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_statsStatement;
      return this;
    }

    StatsStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    StatsStatementContext.prototype.constructor = StatsStatementContext;

    StatsStatementContext.prototype.STATS = function () {
      return this.getToken(GrammarParser.STATS, 0);
    };

    StatsStatementContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    StatsStatementContext.prototype.STATSFUNCS = function () {
      return this.getToken(GrammarParser.STATSFUNCS, 0);
    };

    StatsStatementContext.prototype.LPAREN = function () {
      return this.getToken(GrammarParser.LPAREN, 0);
    };

    StatsStatementContext.prototype.RPAREN = function () {
      return this.getToken(GrammarParser.RPAREN, 0);
    };

    StatsStatementContext.prototype.AS = function () {
      return this.getToken(GrammarParser.AS, 0);
    };

    StatsStatementContext.prototype.STATSTWOPARAMFUNCS = function () {
      return this.getToken(GrammarParser.STATSTWOPARAMFUNCS, 0);
    };

    StatsStatementContext.prototype.number = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(NumberContext);
      } else {
        return this.getTypedRuleContext(NumberContext, i);
      }
    };

    StatsStatementContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    StatsStatementContext.prototype.EXP = function () {
      return this.getToken(GrammarParser.EXP, 0);
    };

    StatsStatementContext.prototype.BY = function () {
      return this.getToken(GrammarParser.BY, 0);
    };

    StatsStatementContext.prototype.SPAN = function () {
      return this.getToken(GrammarParser.SPAN, 0);
    };

    StatsStatementContext.prototype.ASSIGN = function () {
      return this.getToken(GrammarParser.ASSIGN, 0);
    };

    StatsStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterStatsStatement(this);
      }
    };

    StatsStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitStatsStatement(this);
      }
    };

    StatsStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitStatsStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.StatsStatementContext = StatsStatementContext;

    GrammarParser.prototype.statsStatement = function () {
      var localctx = new StatsStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 30, GrammarParser.RULE_statsStatement);
      var _la = 0; // Token type

      try {
        this.state = 447;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 32, this._ctx);

        switch (la_) {
          case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 296;
            this.match(GrammarParser.STATS);
            this.state = 297;
            this.match(GrammarParser.STRLIT);
            break;

          case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 298;
            this.match(GrammarParser.STATS);
            this.state = 299;
            this.match(GrammarParser.STATSFUNCS);
            this.state = 300;
            this.match(GrammarParser.LPAREN);
            this.state = 301;
            this.match(GrammarParser.STRLIT);
            this.state = 306;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 15, this._ctx);

            switch (la_) {
              case 1:
                this.state = 302;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 303;
                this.match(GrammarParser.RPAREN);
                this.state = 304;
                this.match(GrammarParser.AS);
                this.state = 305;
                this.match(GrammarParser.STRLIT);
                break;
            }

            break;

          case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 308;
            this.match(GrammarParser.STATS);
            this.state = 309;
            this.match(GrammarParser.STATSTWOPARAMFUNCS);
            this.state = 310;
            this.match(GrammarParser.LPAREN);
            this.state = 311;
            this.number();
            this.state = 312;
            this.match(GrammarParser.COMMA);
            this.state = 316;

            this._errHandler.sync(this);

            switch (this._input.LA(1)) {
              case GrammarParser.STRLIT:
                this.state = 313;
                this.match(GrammarParser.STRLIT);
                break;

              case GrammarParser.PLUS:
              case GrammarParser.MINUS:
              case GrammarParser.UNSIGNED_INT:
                this.state = 314;
                this.number();
                break;

              case GrammarParser.EXP:
                this.state = 315;
                this.match(GrammarParser.EXP);
                break;

              default:
                throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
            }

            this.state = 322;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 17, this._ctx);

            switch (la_) {
              case 1:
                this.state = 318;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 319;
                this.match(GrammarParser.RPAREN);
                this.state = 320;
                this.match(GrammarParser.AS);
                this.state = 321;
                this.match(GrammarParser.STRLIT);
                break;
            }

            break;

          case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 324;
            this.match(GrammarParser.STATS);
            this.state = 325;
            this.match(GrammarParser.STATSFUNCS);
            this.state = 326;
            this.match(GrammarParser.LPAREN);
            this.state = 327;
            this.match(GrammarParser.STRLIT);
            this.state = 332;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 18, this._ctx);

            switch (la_) {
              case 1:
                this.state = 328;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 329;
                this.match(GrammarParser.RPAREN);
                this.state = 330;
                this.match(GrammarParser.AS);
                this.state = 331;
                this.match(GrammarParser.STRLIT);
                break;
            }

            this.state = 334;
            this.match(GrammarParser.BY);
            this.state = 340;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 20, this._ctx);

            switch (la_) {
              case 1:
                this.state = 335;
                this.match(GrammarParser.STRLIT);
                break;

              case 2:
                this.state = 336;
                this.match(GrammarParser.STRLIT);
                this.state = 338;

                this._errHandler.sync(this);

                _la = this._input.LA(1);

                if (_la === GrammarParser.COMMA) {
                  this.state = 337;
                  this.match(GrammarParser.COMMA);
                }

                break;
            }

            break;

          case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 342;
            this.match(GrammarParser.STATS);
            this.state = 343;
            this.match(GrammarParser.STATSTWOPARAMFUNCS);
            this.state = 344;
            this.match(GrammarParser.LPAREN);
            this.state = 345;
            this.number();
            this.state = 346;
            this.match(GrammarParser.COMMA);
            this.state = 350;

            this._errHandler.sync(this);

            switch (this._input.LA(1)) {
              case GrammarParser.STRLIT:
                this.state = 347;
                this.match(GrammarParser.STRLIT);
                break;

              case GrammarParser.PLUS:
              case GrammarParser.MINUS:
              case GrammarParser.UNSIGNED_INT:
                this.state = 348;
                this.number();
                break;

              case GrammarParser.EXP:
                this.state = 349;
                this.match(GrammarParser.EXP);
                break;

              default:
                throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
            }

            this.state = 356;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 22, this._ctx);

            switch (la_) {
              case 1:
                this.state = 352;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 353;
                this.match(GrammarParser.RPAREN);
                this.state = 354;
                this.match(GrammarParser.AS);
                this.state = 355;
                this.match(GrammarParser.STRLIT);
                break;
            }

            this.state = 358;
            this.match(GrammarParser.BY);
            this.state = 359;
            this.match(GrammarParser.STRLIT);
            this.state = 363;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            while (_la === GrammarParser.COMMA) {
              this.state = 360;
              this.match(GrammarParser.COMMA);
              this.state = 365;

              this._errHandler.sync(this);

              _la = this._input.LA(1);
            }

            break;

          case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 366;
            this.match(GrammarParser.STATS);
            this.state = 367;
            this.match(GrammarParser.STATSFUNCS);
            this.state = 368;
            this.match(GrammarParser.LPAREN);
            this.state = 369;
            this.match(GrammarParser.STRLIT);
            this.state = 374;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 24, this._ctx);

            switch (la_) {
              case 1:
                this.state = 370;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 371;
                this.match(GrammarParser.RPAREN);
                this.state = 372;
                this.match(GrammarParser.AS);
                this.state = 373;
                this.match(GrammarParser.STRLIT);
                break;
            }

            this.state = 376;
            this.match(GrammarParser.SPAN);
            this.state = 377;
            this.match(GrammarParser.ASSIGN);
            this.state = 378;
            this.match(GrammarParser.STRLIT);
            break;

          case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 379;
            this.match(GrammarParser.STATS);
            this.state = 380;
            this.match(GrammarParser.STATSTWOPARAMFUNCS);
            this.state = 381;
            this.match(GrammarParser.LPAREN);
            this.state = 382;
            this.number();
            this.state = 383;
            this.match(GrammarParser.COMMA);
            this.state = 387;

            this._errHandler.sync(this);

            switch (this._input.LA(1)) {
              case GrammarParser.STRLIT:
                this.state = 384;
                this.match(GrammarParser.STRLIT);
                break;

              case GrammarParser.PLUS:
              case GrammarParser.MINUS:
              case GrammarParser.UNSIGNED_INT:
                this.state = 385;
                this.number();
                break;

              case GrammarParser.EXP:
                this.state = 386;
                this.match(GrammarParser.EXP);
                break;

              default:
                throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
            }

            this.state = 393;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 26, this._ctx);

            switch (la_) {
              case 1:
                this.state = 389;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 390;
                this.match(GrammarParser.RPAREN);
                this.state = 391;
                this.match(GrammarParser.AS);
                this.state = 392;
                this.match(GrammarParser.STRLIT);
                break;
            }

            this.state = 395;
            this.match(GrammarParser.SPAN);
            this.state = 396;
            this.match(GrammarParser.ASSIGN);
            this.state = 397;
            this.match(GrammarParser.STRLIT);
            break;

          case 8:
            this.enterOuterAlt(localctx, 8);
            this.state = 399;
            this.match(GrammarParser.STATS);
            this.state = 400;
            this.match(GrammarParser.STATSFUNCS);
            this.state = 401;
            this.match(GrammarParser.LPAREN);
            this.state = 402;
            this.match(GrammarParser.STRLIT);
            this.state = 407;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 27, this._ctx);

            switch (la_) {
              case 1:
                this.state = 403;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 404;
                this.match(GrammarParser.RPAREN);
                this.state = 405;
                this.match(GrammarParser.AS);
                this.state = 406;
                this.match(GrammarParser.STRLIT);
                break;
            }

            this.state = 409;
            this.match(GrammarParser.SPAN);
            this.state = 410;
            this.match(GrammarParser.ASSIGN);
            this.state = 411;
            this.match(GrammarParser.STRLIT);
            this.state = 412;
            this.match(GrammarParser.BY);
            this.state = 413;
            this.match(GrammarParser.STRLIT);
            this.state = 417;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            while (_la === GrammarParser.COMMA) {
              this.state = 414;
              this.match(GrammarParser.COMMA);
              this.state = 419;

              this._errHandler.sync(this);

              _la = this._input.LA(1);
            }

            break;

          case 9:
            this.enterOuterAlt(localctx, 9);
            this.state = 420;
            this.match(GrammarParser.STATS);
            this.state = 421;
            this.match(GrammarParser.STATSTWOPARAMFUNCS);
            this.state = 422;
            this.match(GrammarParser.LPAREN);
            this.state = 423;
            this.number();
            this.state = 424;
            this.match(GrammarParser.COMMA);
            this.state = 428;

            this._errHandler.sync(this);

            switch (this._input.LA(1)) {
              case GrammarParser.STRLIT:
                this.state = 425;
                this.match(GrammarParser.STRLIT);
                break;

              case GrammarParser.PLUS:
              case GrammarParser.MINUS:
              case GrammarParser.UNSIGNED_INT:
                this.state = 426;
                this.number();
                break;

              case GrammarParser.EXP:
                this.state = 427;
                this.match(GrammarParser.EXP);
                break;

              default:
                throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
            }

            this.state = 434;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 30, this._ctx);

            switch (la_) {
              case 1:
                this.state = 430;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 431;
                this.match(GrammarParser.RPAREN);
                this.state = 432;
                this.match(GrammarParser.AS);
                this.state = 433;
                this.match(GrammarParser.STRLIT);
                break;
            }

            this.state = 436;
            this.match(GrammarParser.SPAN);
            this.state = 437;
            this.match(GrammarParser.ASSIGN);
            this.state = 438;
            this.match(GrammarParser.STRLIT);
            this.state = 439;
            this.match(GrammarParser.BY);
            this.state = 440;
            this.match(GrammarParser.STRLIT);
            this.state = 444;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            while (_la === GrammarParser.COMMA) {
              this.state = 441;
              this.match(GrammarParser.COMMA);
              this.state = 446;

              this._errHandler.sync(this);

              _la = this._input.LA(1);
            }

            break;
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function DocStatsStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_docStatsStatement;
      return this;
    }

    DocStatsStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    DocStatsStatementContext.prototype.constructor = DocStatsStatementContext;

    DocStatsStatementContext.prototype.STATS = function () {
      return this.getToken(GrammarParser.STATS, 0);
    };

    DocStatsStatementContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    DocStatsStatementContext.prototype.DOCSTATS = function () {
      return this.getToken(GrammarParser.DOCSTATS, 0);
    };

    DocStatsStatementContext.prototype.STATSFUNCS = function () {
      return this.getToken(GrammarParser.STATSFUNCS, 0);
    };

    DocStatsStatementContext.prototype.LPAREN = function () {
      return this.getToken(GrammarParser.LPAREN, 0);
    };

    DocStatsStatementContext.prototype.RPAREN = function () {
      return this.getToken(GrammarParser.RPAREN, 0);
    };

    DocStatsStatementContext.prototype.AS = function () {
      return this.getToken(GrammarParser.AS, 0);
    };

    DocStatsStatementContext.prototype.STATSTWOPARAMFUNCS = function () {
      return this.getToken(GrammarParser.STATSTWOPARAMFUNCS, 0);
    };

    DocStatsStatementContext.prototype.number = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(NumberContext);
      } else {
        return this.getTypedRuleContext(NumberContext, i);
      }
    };

    DocStatsStatementContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    DocStatsStatementContext.prototype.EXP = function () {
      return this.getToken(GrammarParser.EXP, 0);
    };

    DocStatsStatementContext.prototype.BY = function () {
      return this.getToken(GrammarParser.BY, 0);
    };

    DocStatsStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterDocStatsStatement(this);
      }
    };

    DocStatsStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitDocStatsStatement(this);
      }
    };

    DocStatsStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitDocStatsStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.DocStatsStatementContext = DocStatsStatementContext;

    GrammarParser.prototype.docStatsStatement = function () {
      var localctx = new DocStatsStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 32, GrammarParser.RULE_docStatsStatement);
      var _la = 0; // Token type

      try {
        this.state = 521;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 43, this._ctx);

        switch (la_) {
          case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 449;
            this.match(GrammarParser.STATS);
            this.state = 450;
            this.match(GrammarParser.STRLIT);
            break;

          case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 451;
            this.match(GrammarParser.DOCSTATS);
            this.state = 452;
            this.match(GrammarParser.STATSFUNCS);
            this.state = 453;
            this.match(GrammarParser.LPAREN);
            this.state = 454;
            this.match(GrammarParser.STRLIT);
            this.state = 459;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 33, this._ctx);

            switch (la_) {
              case 1:
                this.state = 455;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 456;
                this.match(GrammarParser.RPAREN);
                this.state = 457;
                this.match(GrammarParser.AS);
                this.state = 458;
                this.match(GrammarParser.STRLIT);
                break;
            }

            break;

          case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 461;
            this.match(GrammarParser.DOCSTATS);
            this.state = 462;
            this.match(GrammarParser.STATSTWOPARAMFUNCS);
            this.state = 463;
            this.match(GrammarParser.LPAREN);
            this.state = 464;
            this.number();
            this.state = 465;
            this.match(GrammarParser.COMMA);
            this.state = 469;

            this._errHandler.sync(this);

            switch (this._input.LA(1)) {
              case GrammarParser.STRLIT:
                this.state = 466;
                this.match(GrammarParser.STRLIT);
                break;

              case GrammarParser.PLUS:
              case GrammarParser.MINUS:
              case GrammarParser.UNSIGNED_INT:
                this.state = 467;
                this.number();
                break;

              case GrammarParser.EXP:
                this.state = 468;
                this.match(GrammarParser.EXP);
                break;

              default:
                throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
            }

            this.state = 475;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 35, this._ctx);

            switch (la_) {
              case 1:
                this.state = 471;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 472;
                this.match(GrammarParser.RPAREN);
                this.state = 473;
                this.match(GrammarParser.AS);
                this.state = 474;
                this.match(GrammarParser.STRLIT);
                break;
            }

            break;

          case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 477;
            this.match(GrammarParser.DOCSTATS);
            this.state = 478;
            this.match(GrammarParser.STATSFUNCS);
            this.state = 479;
            this.match(GrammarParser.LPAREN);
            this.state = 480;
            this.match(GrammarParser.STRLIT);
            this.state = 485;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 36, this._ctx);

            switch (la_) {
              case 1:
                this.state = 481;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 482;
                this.match(GrammarParser.RPAREN);
                this.state = 483;
                this.match(GrammarParser.AS);
                this.state = 484;
                this.match(GrammarParser.STRLIT);
                break;
            }

            this.state = 487;
            this.match(GrammarParser.BY);
            this.state = 492;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            do {
              this.state = 488;
              this.match(GrammarParser.STRLIT);
              this.state = 490;

              this._errHandler.sync(this);

              _la = this._input.LA(1);

              if (_la === GrammarParser.COMMA) {
                this.state = 489;
                this.match(GrammarParser.COMMA);
              }

              this.state = 494;

              this._errHandler.sync(this);

              _la = this._input.LA(1);
            } while (_la === GrammarParser.STRLIT);

            break;

          case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 496;
            this.match(GrammarParser.DOCSTATS);
            this.state = 497;
            this.match(GrammarParser.STATSTWOPARAMFUNCS);
            this.state = 498;
            this.match(GrammarParser.LPAREN);
            this.state = 499;
            this.number();
            this.state = 500;
            this.match(GrammarParser.COMMA);
            this.state = 504;

            this._errHandler.sync(this);

            switch (this._input.LA(1)) {
              case GrammarParser.STRLIT:
                this.state = 501;
                this.match(GrammarParser.STRLIT);
                break;

              case GrammarParser.PLUS:
              case GrammarParser.MINUS:
              case GrammarParser.UNSIGNED_INT:
                this.state = 502;
                this.number();
                break;

              case GrammarParser.EXP:
                this.state = 503;
                this.match(GrammarParser.EXP);
                break;

              default:
                throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
            }

            this.state = 510;

            this._errHandler.sync(this);

            var la_ = this._interp.adaptivePredict(this._input, 40, this._ctx);

            switch (la_) {
              case 1:
                this.state = 506;
                this.match(GrammarParser.RPAREN);
                break;

              case 2:
                this.state = 507;
                this.match(GrammarParser.RPAREN);
                this.state = 508;
                this.match(GrammarParser.AS);
                this.state = 509;
                this.match(GrammarParser.STRLIT);
                break;
            }

            this.state = 512;
            this.match(GrammarParser.BY);
            this.state = 517;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            do {
              this.state = 513;
              this.match(GrammarParser.STRLIT);
              this.state = 515;

              this._errHandler.sync(this);

              _la = this._input.LA(1);

              if (_la === GrammarParser.COMMA) {
                this.state = 514;
                this.match(GrammarParser.COMMA);
              }

              this.state = 519;

              this._errHandler.sync(this);

              _la = this._input.LA(1);
            } while (_la === GrammarParser.STRLIT);

            break;
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function StreamStatsStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_streamStatsStatement;
      return this;
    }

    StreamStatsStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    StreamStatsStatementContext.prototype.constructor = StreamStatsStatementContext;

    StreamStatsStatementContext.prototype.STREAMSTATS = function () {
      return this.getToken(GrammarParser.STREAMSTATS, 0);
    };

    StreamStatsStatementContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    StreamStatsStatementContext.prototype.AS = function () {
      return this.getToken(GrammarParser.AS, 0);
    };

    StreamStatsStatementContext.prototype.BY = function () {
      return this.getToken(GrammarParser.BY, 0);
    };

    StreamStatsStatementContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    StreamStatsStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterStreamStatsStatement(this);
      }
    };

    StreamStatsStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitStreamStatsStatement(this);
      }
    };

    StreamStatsStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitStreamStatsStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.StreamStatsStatementContext = StreamStatsStatementContext;

    GrammarParser.prototype.streamStatsStatement = function () {
      var localctx = new StreamStatsStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 34, GrammarParser.RULE_streamStatsStatement);
      var _la = 0; // Token type

      try {
        this.state = 544;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 46, this._ctx);

        switch (la_) {
          case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 523;
            this.match(GrammarParser.STREAMSTATS);
            this.state = 524;
            this.match(GrammarParser.STRLIT);
            break;

          case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 525;
            this.match(GrammarParser.STREAMSTATS);
            this.state = 526;
            this.match(GrammarParser.STRLIT);
            this.state = 527;
            this.match(GrammarParser.AS);
            this.state = 528;
            this.match(GrammarParser.STRLIT);
            break;

          case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 529;
            this.match(GrammarParser.STREAMSTATS);
            this.state = 530;
            this.match(GrammarParser.STRLIT);
            this.state = 533;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            if (_la === GrammarParser.AS) {
              this.state = 531;
              this.match(GrammarParser.AS);
              this.state = 532;
              this.match(GrammarParser.STRLIT);
            }

            this.state = 535;
            this.match(GrammarParser.BY);
            this.state = 536;
            this.match(GrammarParser.STRLIT);
            this.state = 541;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            while (_la === GrammarParser.COMMA) {
              this.state = 537;
              this.match(GrammarParser.COMMA);
              this.state = 538;
              this.match(GrammarParser.STRLIT);
              this.state = 543;

              this._errHandler.sync(this);

              _la = this._input.LA(1);
            }

            break;
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function StatsfieldContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_statsfield;
      return this;
    }

    StatsfieldContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    StatsfieldContext.prototype.constructor = StatsfieldContext;

    StatsfieldContext.prototype.STATSFUNCS = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STATSFUNCS);
      } else {
        return this.getToken(GrammarParser.STATSFUNCS, i);
      }
    };

    StatsfieldContext.prototype.LPAREN = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.LPAREN);
      } else {
        return this.getToken(GrammarParser.LPAREN, i);
      }
    };

    StatsfieldContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    StatsfieldContext.prototype.RPAREN = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.RPAREN);
      } else {
        return this.getToken(GrammarParser.RPAREN, i);
      }
    };

    StatsfieldContext.prototype.AS = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.AS);
      } else {
        return this.getToken(GrammarParser.AS, i);
      }
    };

    StatsfieldContext.prototype.STATSTWOPARAMFUNCS = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STATSTWOPARAMFUNCS);
      } else {
        return this.getToken(GrammarParser.STATSTWOPARAMFUNCS, i);
      }
    };

    StatsfieldContext.prototype.number = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(NumberContext);
      } else {
        return this.getTypedRuleContext(NumberContext, i);
      }
    };

    StatsfieldContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    StatsfieldContext.prototype.EXP = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.EXP);
      } else {
        return this.getToken(GrammarParser.EXP, i);
      }
    };

    StatsfieldContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterStatsfield(this);
      }
    };

    StatsfieldContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitStatsfield(this);
      }
    };

    StatsfieldContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitStatsfield(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.StatsfieldContext = StatsfieldContext;

    GrammarParser.prototype.statsfield = function () {
      var localctx = new StatsfieldContext(this, this._ctx, this.state);
      this.enterRule(localctx, 36, GrammarParser.RULE_statsfield);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 552;

        this._errHandler.sync(this);

        var _alt = this._interp.adaptivePredict(this._input, 47, this._ctx);

        while (_alt != 2 && _alt != antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.atn.ATN.INVALID_ALT_NUMBER) {
          if (_alt === 1) {
            this.state = 546;
            this.match(GrammarParser.STATSFUNCS);
            this.state = 547;
            this.match(GrammarParser.LPAREN);
            this.state = 548;
            this.match(GrammarParser.STRLIT);
            this.state = 549;
            this.match(GrammarParser.RPAREN);
          }

          this.state = 554;

          this._errHandler.sync(this);

          _alt = this._interp.adaptivePredict(this._input, 47, this._ctx);
        }

        this.state = 563;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.STATSFUNCS) {
          this.state = 555;
          this.match(GrammarParser.STATSFUNCS);
          this.state = 556;
          this.match(GrammarParser.LPAREN);
          this.state = 557;
          this.match(GrammarParser.STRLIT);
          this.state = 558;
          this.match(GrammarParser.RPAREN);
          this.state = 559;
          this.match(GrammarParser.AS);
          this.state = 560;
          this.match(GrammarParser.STRLIT);
          this.state = 565;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }

        this.state = 579;

        this._errHandler.sync(this);

        var _alt = this._interp.adaptivePredict(this._input, 50, this._ctx);

        while (_alt != 2 && _alt != antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.atn.ATN.INVALID_ALT_NUMBER) {
          if (_alt === 1) {
            this.state = 566;
            this.match(GrammarParser.STATSTWOPARAMFUNCS);
            this.state = 567;
            this.match(GrammarParser.LPAREN);
            this.state = 568;
            this.number();
            this.state = 569;
            this.match(GrammarParser.COMMA);
            this.state = 573;

            this._errHandler.sync(this);

            switch (this._input.LA(1)) {
              case GrammarParser.STRLIT:
                this.state = 570;
                this.match(GrammarParser.STRLIT);
                break;

              case GrammarParser.PLUS:
              case GrammarParser.MINUS:
              case GrammarParser.UNSIGNED_INT:
                this.state = 571;
                this.number();
                break;

              case GrammarParser.EXP:
                this.state = 572;
                this.match(GrammarParser.EXP);
                break;

              default:
                throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
            }

            this.state = 575;
            this.match(GrammarParser.RPAREN);
          }

          this.state = 581;

          this._errHandler.sync(this);

          _alt = this._interp.adaptivePredict(this._input, 50, this._ctx);
        }

        this.state = 597;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.STATSTWOPARAMFUNCS) {
          this.state = 582;
          this.match(GrammarParser.STATSTWOPARAMFUNCS);
          this.state = 583;
          this.match(GrammarParser.LPAREN);
          this.state = 584;
          this.number();
          this.state = 585;
          this.match(GrammarParser.COMMA);
          this.state = 589;

          this._errHandler.sync(this);

          switch (this._input.LA(1)) {
            case GrammarParser.STRLIT:
              this.state = 586;
              this.match(GrammarParser.STRLIT);
              break;

            case GrammarParser.PLUS:
            case GrammarParser.MINUS:
            case GrammarParser.UNSIGNED_INT:
              this.state = 587;
              this.number();
              break;

            case GrammarParser.EXP:
              this.state = 588;
              this.match(GrammarParser.EXP);
              break;

            default:
              throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
          }

          this.state = 591;
          this.match(GrammarParser.RPAREN);
          this.state = 592;
          this.match(GrammarParser.AS);
          this.state = 593;
          this.match(GrammarParser.STRLIT);
          this.state = 599;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function SortStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_sortStatement;
      return this;
    }

    SortStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    SortStatementContext.prototype.constructor = SortStatementContext;

    SortStatementContext.prototype.SORT = function () {
      return this.getToken(GrammarParser.SORT, 0);
    };

    SortStatementContext.prototype.ASC = function () {
      return this.getToken(GrammarParser.ASC, 0);
    };

    SortStatementContext.prototype.DESC = function () {
      return this.getToken(GrammarParser.DESC, 0);
    };

    SortStatementContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    SortStatementContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    SortStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterSortStatement(this);
      }
    };

    SortStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitSortStatement(this);
      }
    };

    SortStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitSortStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.SortStatementContext = SortStatementContext;

    GrammarParser.prototype.sortStatement = function () {
      var localctx = new SortStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 38, GrammarParser.RULE_sortStatement);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 600;
        this.match(GrammarParser.SORT);
        this.state = 601;
        _la = this._input.LA(1);

        if (!(_la === GrammarParser.ASC || _la === GrammarParser.DESC)) {
          this._errHandler.recoverInline(this);
        } else {
          this._errHandler.reportMatch(this);

          this.consume();
        }

        this.state = 606;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        do {
          this.state = 602;
          this.match(GrammarParser.STRLIT);
          this.state = 604;

          this._errHandler.sync(this);

          _la = this._input.LA(1);

          if (_la === GrammarParser.COMMA) {
            this.state = 603;
            this.match(GrammarParser.COMMA);
          }

          this.state = 608;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        } while (_la === GrammarParser.STRLIT);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MergeStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_mergeStatement;
      return this;
    }

    MergeStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MergeStatementContext.prototype.constructor = MergeStatementContext;

    MergeStatementContext.prototype.MERGE = function () {
      return this.getToken(GrammarParser.MERGE, 0);
    };

    MergeStatementContext.prototype.mergeoptions = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(MergeoptionsContext);
      } else {
        return this.getTypedRuleContext(MergeoptionsContext, i);
      }
    };

    MergeStatementContext.prototype.BY = function () {
      return this.getToken(GrammarParser.BY, 0);
    };

    MergeStatementContext.prototype.mergeFields = function () {
      return this.getTypedRuleContext(MergeFieldsContext, 0);
    };

    MergeStatementContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    MergeStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMergeStatement(this);
      }
    };

    MergeStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMergeStatement(this);
      }
    };

    MergeStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMergeStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MergeStatementContext = MergeStatementContext;

    GrammarParser.prototype.mergeStatement = function () {
      var localctx = new MergeStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 40, GrammarParser.RULE_mergeStatement);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 610;
        this.match(GrammarParser.MERGE);
        this.state = 611;
        this.mergeoptions();
        this.state = 616;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.COMMA) {
          this.state = 612;
          this.match(GrammarParser.COMMA);
          this.state = 613;
          this.mergeoptions();
          this.state = 618;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }

        this.state = 619;
        this.match(GrammarParser.BY);
        this.state = 620;
        this.mergeFields();
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MergeoptionsContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_mergeoptions;
      return this;
    }

    MergeoptionsContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MergeoptionsContext.prototype.constructor = MergeoptionsContext;

    MergeoptionsContext.prototype.mergeoption = function () {
      return this.getTypedRuleContext(MergeoptionContext, 0);
    };

    MergeoptionsContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    MergeoptionsContext.prototype.FIRST = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.FIRST);
      } else {
        return this.getToken(GrammarParser.FIRST, i);
      }
    };

    MergeoptionsContext.prototype.LAST = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.LAST);
      } else {
        return this.getToken(GrammarParser.LAST, i);
      }
    };

    MergeoptionsContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMergeoptions(this);
      }
    };

    MergeoptionsContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMergeoptions(this);
      }
    };

    MergeoptionsContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMergeoptions(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MergeoptionsContext = MergeoptionsContext;

    GrammarParser.prototype.mergeoptions = function () {
      var localctx = new MergeoptionsContext(this, this._ctx, this.state);
      this.enterRule(localctx, 42, GrammarParser.RULE_mergeoptions);
      var _la = 0; // Token type

      try {
        this.state = 632;

        this._errHandler.sync(this);

        switch (this._input.LA(1)) {
          case GrammarParser.EXCLUDE:
          case GrammarParser.INCLUDE:
            this.enterOuterAlt(localctx, 1);
            this.state = 622;
            this.mergeoption();
            this.state = 626;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            while (_la === GrammarParser.FIRST || _la === GrammarParser.LAST) {
              this.state = 623;
              _la = this._input.LA(1);

              if (!(_la === GrammarParser.FIRST || _la === GrammarParser.LAST)) {
                this._errHandler.recoverInline(this);
              } else {
                this._errHandler.reportMatch(this);

                this.consume();
              }

              this.state = 628;

              this._errHandler.sync(this);

              _la = this._input.LA(1);
            }

            this.state = 629;
            this.match(GrammarParser.STRLIT);
            break;

          case GrammarParser.STRLIT:
            this.enterOuterAlt(localctx, 2);
            this.state = 631;
            this.match(GrammarParser.STRLIT);
            break;

          default:
            throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MergeoptionContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_mergeoption;
      return this;
    }

    MergeoptionContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MergeoptionContext.prototype.constructor = MergeoptionContext;

    MergeoptionContext.prototype.ASSIGN = function () {
      return this.getToken(GrammarParser.ASSIGN, 0);
    };

    MergeoptionContext.prototype.LMIDDLE = function () {
      return this.getToken(GrammarParser.LMIDDLE, 0);
    };

    MergeoptionContext.prototype.values = function () {
      return this.getTypedRuleContext(ValuesContext, 0);
    };

    MergeoptionContext.prototype.RMIDDLE = function () {
      return this.getToken(GrammarParser.RMIDDLE, 0);
    };

    MergeoptionContext.prototype.EXCLUDE = function () {
      return this.getToken(GrammarParser.EXCLUDE, 0);
    };

    MergeoptionContext.prototype.INCLUDE = function () {
      return this.getToken(GrammarParser.INCLUDE, 0);
    };

    MergeoptionContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMergeoption(this);
      }
    };

    MergeoptionContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMergeoption(this);
      }
    };

    MergeoptionContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMergeoption(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MergeoptionContext = MergeoptionContext;

    GrammarParser.prototype.mergeoption = function () {
      var localctx = new MergeoptionContext(this, this._ctx, this.state);
      this.enterRule(localctx, 44, GrammarParser.RULE_mergeoption);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 634;
        _la = this._input.LA(1);

        if (!(_la === GrammarParser.EXCLUDE || _la === GrammarParser.INCLUDE)) {
          this._errHandler.recoverInline(this);
        } else {
          this._errHandler.reportMatch(this);

          this.consume();
        }

        this.state = 635;
        this.match(GrammarParser.ASSIGN);
        this.state = 636;
        this.match(GrammarParser.LMIDDLE);
        this.state = 637;
        this.values();
        this.state = 638;
        this.match(GrammarParser.RMIDDLE);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function ValuesContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_values;
      return this;
    }

    ValuesContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    ValuesContext.prototype.constructor = ValuesContext;

    ValuesContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    ValuesContext.prototype.INTLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.INTLIT);
      } else {
        return this.getToken(GrammarParser.INTLIT, i);
      }
    };

    ValuesContext.prototype.DECLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.DECLIT);
      } else {
        return this.getToken(GrammarParser.DECLIT, i);
      }
    };

    ValuesContext.prototype.NULL = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.NULL);
      } else {
        return this.getToken(GrammarParser.NULL, i);
      }
    };

    ValuesContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    ValuesContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterValues(this);
      }
    };

    ValuesContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitValues(this);
      }
    };

    ValuesContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitValues(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.ValuesContext = ValuesContext;

    GrammarParser.prototype.values = function () {
      var localctx = new ValuesContext(this, this._ctx, this.state);
      this.enterRule(localctx, 46, GrammarParser.RULE_values);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 640;
        _la = this._input.LA(1);

        if (!((_la - 57 & ~0x1f) == 0 && (1 << _la - 57 & (1 << GrammarParser.INTLIT - 57 | 1 << GrammarParser.DECLIT - 57 | 1 << GrammarParser.STRLIT - 57 | 1 << GrammarParser.NULL - 57)) !== 0)) {
          this._errHandler.recoverInline(this);
        } else {
          this._errHandler.reportMatch(this);

          this.consume();
        }

        this.state = 651;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.COMMA) {
          this.state = 641;
          this.match(GrammarParser.COMMA);
          this.state = 647;

          this._errHandler.sync(this);

          switch (this._input.LA(1)) {
            case GrammarParser.STRLIT:
              this.state = 642;
              this.match(GrammarParser.STRLIT);
              break;

            case GrammarParser.RMIDDLE:
            case GrammarParser.COMMA:
              break;

            case GrammarParser.INTLIT:
              this.state = 644;
              this.match(GrammarParser.INTLIT);
              break;

            case GrammarParser.DECLIT:
              this.state = 645;
              this.match(GrammarParser.DECLIT);
              break;

            case GrammarParser.NULL:
              this.state = 646;
              this.match(GrammarParser.NULL);
              break;

            default:
              throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
          }

          this.state = 653;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MergeFieldsContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_mergeFields;
      return this;
    }

    MergeFieldsContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MergeFieldsContext.prototype.constructor = MergeFieldsContext;

    MergeFieldsContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    MergeFieldsContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    MergeFieldsContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMergeFields(this);
      }
    };

    MergeFieldsContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMergeFields(this);
      }
    };

    MergeFieldsContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMergeFields(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MergeFieldsContext = MergeFieldsContext;

    GrammarParser.prototype.mergeFields = function () {
      var localctx = new MergeFieldsContext(this, this._ctx, this.state);
      this.enterRule(localctx, 48, GrammarParser.RULE_mergeFields);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 654;
        this.match(GrammarParser.STRLIT);
        this.state = 659;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.COMMA) {
          this.state = 655;
          this.match(GrammarParser.COMMA);
          this.state = 656;
          this.match(GrammarParser.STRLIT);
          this.state = 661;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function TopStatementContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_topStatement;
      return this;
    }

    TopStatementContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    TopStatementContext.prototype.constructor = TopStatementContext;

    TopStatementContext.prototype.TOP = function () {
      return this.getToken(GrammarParser.TOP, 0);
    };

    TopStatementContext.prototype.topFields = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(TopFieldsContext);
      } else {
        return this.getTypedRuleContext(TopFieldsContext, i);
      }
    };

    TopStatementContext.prototype.topOption = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(TopOptionContext);
      } else {
        return this.getTypedRuleContext(TopOptionContext, i);
      }
    };

    TopStatementContext.prototype.BY = function () {
      return this.getToken(GrammarParser.BY, 0);
    };

    TopStatementContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterTopStatement(this);
      }
    };

    TopStatementContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitTopStatement(this);
      }
    };

    TopStatementContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitTopStatement(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.TopStatementContext = TopStatementContext;

    GrammarParser.prototype.topStatement = function () {
      var localctx = new TopStatementContext(this, this._ctx, this.state);
      this.enterRule(localctx, 50, GrammarParser.RULE_topStatement);
      var _la = 0; // Token type

      try {
        this.state = 681;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 63, this._ctx);

        switch (la_) {
          case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 662;
            this.match(GrammarParser.TOP);
            this.state = 666;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            while ((_la - 31 & ~0x1f) == 0 && (1 << _la - 31 & (1 << GrammarParser.LIMIT - 31 | 1 << GrammarParser.INTLIT - 31 | 1 << GrammarParser.DECLIT - 31)) !== 0) {
              this.state = 663;
              this.topOption();
              this.state = 668;

              this._errHandler.sync(this);

              _la = this._input.LA(1);
            }

            this.state = 669;
            this.topFields();
            break;

          case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 670;
            this.match(GrammarParser.TOP);
            this.state = 674;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            while ((_la - 31 & ~0x1f) == 0 && (1 << _la - 31 & (1 << GrammarParser.LIMIT - 31 | 1 << GrammarParser.INTLIT - 31 | 1 << GrammarParser.DECLIT - 31)) !== 0) {
              this.state = 671;
              this.topOption();
              this.state = 676;

              this._errHandler.sync(this);

              _la = this._input.LA(1);
            }

            this.state = 677;
            this.topFields();
            this.state = 678;
            this.match(GrammarParser.BY);
            this.state = 679;
            this.topFields();
            break;
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function TopOptionContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_topOption;
      return this;
    }

    TopOptionContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    TopOptionContext.prototype.constructor = TopOptionContext;

    TopOptionContext.prototype.LIMIT = function () {
      return this.getToken(GrammarParser.LIMIT, 0);
    };

    TopOptionContext.prototype.ASSIGN = function () {
      return this.getToken(GrammarParser.ASSIGN, 0);
    };

    TopOptionContext.prototype.INTLIT = function () {
      return this.getToken(GrammarParser.INTLIT, 0);
    };

    TopOptionContext.prototype.DECLIT = function () {
      return this.getToken(GrammarParser.DECLIT, 0);
    };

    TopOptionContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterTopOption(this);
      }
    };

    TopOptionContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitTopOption(this);
      }
    };

    TopOptionContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitTopOption(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.TopOptionContext = TopOptionContext;

    GrammarParser.prototype.topOption = function () {
      var localctx = new TopOptionContext(this, this._ctx, this.state);
      this.enterRule(localctx, 52, GrammarParser.RULE_topOption);
      var _la = 0; // Token type

      try {
        this.state = 687;

        this._errHandler.sync(this);

        switch (this._input.LA(1)) {
          case GrammarParser.LIMIT:
            this.enterOuterAlt(localctx, 1);
            this.state = 683;
            this.match(GrammarParser.LIMIT);
            this.state = 684;
            this.match(GrammarParser.ASSIGN);
            this.state = 685;
            _la = this._input.LA(1);

            if (!(_la === GrammarParser.INTLIT || _la === GrammarParser.DECLIT)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            break;

          case GrammarParser.INTLIT:
          case GrammarParser.DECLIT:
            this.enterOuterAlt(localctx, 2);
            this.state = 686;
            _la = this._input.LA(1);

            if (!(_la === GrammarParser.INTLIT || _la === GrammarParser.DECLIT)) {
              this._errHandler.recoverInline(this);
            } else {
              this._errHandler.reportMatch(this);

              this.consume();
            }

            break;

          default:
            throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function TopFieldsContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_topFields;
      return this;
    }

    TopFieldsContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    TopFieldsContext.prototype.constructor = TopFieldsContext;

    TopFieldsContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    TopFieldsContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    TopFieldsContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterTopFields(this);
      }
    };

    TopFieldsContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitTopFields(this);
      }
    };

    TopFieldsContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitTopFields(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.TopFieldsContext = TopFieldsContext;

    GrammarParser.prototype.topFields = function () {
      var localctx = new TopFieldsContext(this, this._ctx, this.state);
      this.enterRule(localctx, 54, GrammarParser.RULE_topFields);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 689;
        this.match(GrammarParser.STRLIT);
        this.state = 694;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.COMMA) {
          this.state = 690;
          this.match(GrammarParser.COMMA);
          this.state = 691;
          this.match(GrammarParser.STRLIT);
          this.state = 696;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function SortlimitContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_sortlimit;
      return this;
    }

    SortlimitContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    SortlimitContext.prototype.constructor = SortlimitContext;

    SortlimitContext.prototype.ALL = function () {
      return this.getToken(GrammarParser.ALL, 0);
    };

    SortlimitContext.prototype.unsignedNumber = function () {
      return this.getTypedRuleContext(UnsignedNumberContext, 0);
    };

    SortlimitContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterSortlimit(this);
      }
    };

    SortlimitContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitSortlimit(this);
      }
    };

    SortlimitContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitSortlimit(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.SortlimitContext = SortlimitContext;

    GrammarParser.prototype.sortlimit = function () {
      var localctx = new SortlimitContext(this, this._ctx, this.state);
      this.enterRule(localctx, 56, GrammarParser.RULE_sortlimit);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 699;

        this._errHandler.sync(this);

        switch (this._input.LA(1)) {
          case GrammarParser.ALL:
            this.state = 697;
            this.match(GrammarParser.ALL);
            break;

          case GrammarParser.UNSIGNED_INT:
            this.state = 698;
            this.unsignedNumber();
            break;

          default:
            throw new antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.NoViableAltException(this);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function NumberContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_number;
      return this;
    }

    NumberContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    NumberContext.prototype.constructor = NumberContext;

    NumberContext.prototype.unsignedNumber = function () {
      return this.getTypedRuleContext(UnsignedNumberContext, 0);
    };

    NumberContext.prototype.unaryOperator = function () {
      return this.getTypedRuleContext(UnaryOperatorContext, 0);
    };

    NumberContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterNumber(this);
      }
    };

    NumberContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitNumber(this);
      }
    };

    NumberContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitNumber(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.NumberContext = NumberContext;

    GrammarParser.prototype.number = function () {
      var localctx = new NumberContext(this, this._ctx, this.state);
      this.enterRule(localctx, 58, GrammarParser.RULE_number);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 702;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        if (_la === GrammarParser.PLUS || _la === GrammarParser.MINUS) {
          this.state = 701;
          this.unaryOperator();
        }

        this.state = 704;
        this.unsignedNumber();
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function UnaryOperatorContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_unaryOperator;
      return this;
    }

    UnaryOperatorContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    UnaryOperatorContext.prototype.constructor = UnaryOperatorContext;

    UnaryOperatorContext.prototype.PLUS = function () {
      return this.getToken(GrammarParser.PLUS, 0);
    };

    UnaryOperatorContext.prototype.MINUS = function () {
      return this.getToken(GrammarParser.MINUS, 0);
    };

    UnaryOperatorContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterUnaryOperator(this);
      }
    };

    UnaryOperatorContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitUnaryOperator(this);
      }
    };

    UnaryOperatorContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitUnaryOperator(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.UnaryOperatorContext = UnaryOperatorContext;

    GrammarParser.prototype.unaryOperator = function () {
      var localctx = new UnaryOperatorContext(this, this._ctx, this.state);
      this.enterRule(localctx, 60, GrammarParser.RULE_unaryOperator);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 706;
        _la = this._input.LA(1);

        if (!(_la === GrammarParser.PLUS || _la === GrammarParser.MINUS)) {
          this._errHandler.recoverInline(this);
        } else {
          this._errHandler.reportMatch(this);

          this.consume();
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function UnsignedNumberContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_unsignedNumber;
      return this;
    }

    UnsignedNumberContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    UnsignedNumberContext.prototype.constructor = UnsignedNumberContext;

    UnsignedNumberContext.prototype.UNSIGNED_INT = function () {
      return this.getToken(GrammarParser.UNSIGNED_INT, 0);
    };

    UnsignedNumberContext.prototype.floatVal = function () {
      return this.getTypedRuleContext(FloatValContext, 0);
    };

    UnsignedNumberContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterUnsignedNumber(this);
      }
    };

    UnsignedNumberContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitUnsignedNumber(this);
      }
    };

    UnsignedNumberContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitUnsignedNumber(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.UnsignedNumberContext = UnsignedNumberContext;

    GrammarParser.prototype.unsignedNumber = function () {
      var localctx = new UnsignedNumberContext(this, this._ctx, this.state);
      this.enterRule(localctx, 62, GrammarParser.RULE_unsignedNumber);

      try {
        this.state = 710;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 68, this._ctx);

        switch (la_) {
          case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 708;
            this.match(GrammarParser.UNSIGNED_INT);
            break;

          case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 709;
            this.floatVal();
            break;
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function FloatValContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_floatVal;
      return this;
    }

    FloatValContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    FloatValContext.prototype.constructor = FloatValContext;

    FloatValContext.prototype.UNSIGNED_INT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.UNSIGNED_INT);
      } else {
        return this.getToken(GrammarParser.UNSIGNED_INT, i);
      }
    };

    FloatValContext.prototype.DOT = function () {
      return this.getToken(GrammarParser.DOT, 0);
    };

    FloatValContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterFloatVal(this);
      }
    };

    FloatValContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitFloatVal(this);
      }
    };

    FloatValContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitFloatVal(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.FloatValContext = FloatValContext;

    GrammarParser.prototype.floatVal = function () {
      var localctx = new FloatValContext(this, this._ctx, this.state);
      this.enterRule(localctx, 64, GrammarParser.RULE_floatVal);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 712;
        this.match(GrammarParser.UNSIGNED_INT);
        this.state = 713;
        this.match(GrammarParser.DOT);
        this.state = 715;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        do {
          this.state = 714;
          this.match(GrammarParser.UNSIGNED_INT);
          this.state = 717;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        } while (_la === GrammarParser.UNSIGNED_INT);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function FetchlogQueryContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_fetchlogQuery;
      return this;
    }

    FetchlogQueryContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    FetchlogQueryContext.prototype.constructor = FetchlogQueryContext;

    FetchlogQueryContext.prototype.FETCHLOG = function () {
      return this.getToken(GrammarParser.FETCHLOG, 0);
    };

    FetchlogQueryContext.prototype.INDEX = function () {
      return this.getToken(GrammarParser.INDEX, 0);
    };

    FetchlogQueryContext.prototype.COLON = function () {
      return this.getToken(GrammarParser.COLON, 0);
    };

    FetchlogQueryContext.prototype.indexpattern = function () {
      return this.getTypedRuleContext(IndexpatternContext, 0);
    };

    FetchlogQueryContext.prototype.whereStatement = function () {
      return this.getTypedRuleContext(WhereStatementContext, 0);
    };

    FetchlogQueryContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterFetchlogQuery(this);
      }
    };

    FetchlogQueryContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitFetchlogQuery(this);
      }
    };

    FetchlogQueryContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitFetchlogQuery(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.FetchlogQueryContext = FetchlogQueryContext;

    GrammarParser.prototype.fetchlogQuery = function () {
      var localctx = new FetchlogQueryContext(this, this._ctx, this.state);
      this.enterRule(localctx, 66, GrammarParser.RULE_fetchlogQuery);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 719;
        this.match(GrammarParser.FETCHLOG);
        this.state = 720;
        this.match(GrammarParser.INDEX);
        this.state = 721;
        this.match(GrammarParser.COLON);
        this.state = 722;
        this.indexpattern();
        this.state = 724;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        if (_la === GrammarParser.WHERE) {
          this.state = 723;
          this.whereStatement();
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function IndexpatternContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_indexpattern;
      return this;
    }

    IndexpatternContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    IndexpatternContext.prototype.constructor = IndexpatternContext;

    IndexpatternContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    IndexpatternContext.prototype.EXP = function () {
      return this.getToken(GrammarParser.EXP, 0);
    };

    IndexpatternContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterIndexpattern(this);
      }
    };

    IndexpatternContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitIndexpattern(this);
      }
    };

    IndexpatternContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitIndexpattern(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.IndexpatternContext = IndexpatternContext;

    GrammarParser.prototype.indexpattern = function () {
      var localctx = new IndexpatternContext(this, this._ctx, this.state);
      this.enterRule(localctx, 68, GrammarParser.RULE_indexpattern);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 726;
        _la = this._input.LA(1);

        if (!(_la === GrammarParser.STRLIT || _la === GrammarParser.EXP)) {
          this._errHandler.recoverInline(this);
        } else {
          this._errHandler.reportMatch(this);

          this.consume();
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function JoinContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_join;
      return this;
    }

    JoinContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    JoinContext.prototype.constructor = JoinContext;

    JoinContext.prototype.JOIN = function () {
      return this.getToken(GrammarParser.JOIN, 0);
    };

    JoinContext.prototype.ON = function () {
      return this.getToken(GrammarParser.ON, 0);
    };

    JoinContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    JoinContext.prototype.LBRACE = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.LBRACE);
      } else {
        return this.getToken(GrammarParser.LBRACE, i);
      }
    };

    JoinContext.prototype.statement = function () {
      return this.getTypedRuleContext(StatementContext, 0);
    };

    JoinContext.prototype.jointype = function () {
      return this.getTypedRuleContext(JointypeContext, 0);
    };

    JoinContext.prototype.maxmatchdoc = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(MaxmatchdocContext);
      } else {
        return this.getTypedRuleContext(MaxmatchdocContext, i);
      }
    };

    JoinContext.prototype.overridefield = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(OverridefieldContext);
      } else {
        return this.getTypedRuleContext(OverridefieldContext, i);
      }
    };

    JoinContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterJoin(this);
      }
    };

    JoinContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitJoin(this);
      }
    };

    JoinContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitJoin(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.JoinContext = JoinContext;

    GrammarParser.prototype.join = function () {
      var localctx = new JoinContext(this, this._ctx, this.state);
      this.enterRule(localctx, 70, GrammarParser.RULE_join);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 728;
        this.match(GrammarParser.JOIN);
        this.state = 730;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        if (_la === GrammarParser.LEFT || _la === GrammarParser.INNER) {
          this.state = 729;
          this.jointype();
        }

        this.state = 732;
        this.match(GrammarParser.ON);
        this.state = 733;
        this.match(GrammarParser.STRLIT);
        this.state = 736;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 72, this._ctx);

        if (la_ === 1) {
          this.state = 734;
          this.maxmatchdoc();
        } else if (la_ === 2) {
          this.state = 735;
          this.overridefield();
        }

        this.state = 740;

        this._errHandler.sync(this);

        switch (this._input.LA(1)) {
          case GrammarParser.MAXMATCH:
            this.state = 738;
            this.maxmatchdoc();
            break;

          case GrammarParser.OVERRIDE:
            this.state = 739;
            this.overridefield();
            break;

          case GrammarParser.LBRACE:
            break;

          default:
            break;
        }

        this.state = 742;
        this.match(GrammarParser.LBRACE);
        this.state = 743;
        this.statement();
        this.state = 744;
        this.match(GrammarParser.LBRACE);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function JointypeContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_jointype;
      return this;
    }

    JointypeContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    JointypeContext.prototype.constructor = JointypeContext;

    JointypeContext.prototype.LEFT = function () {
      return this.getToken(GrammarParser.LEFT, 0);
    };

    JointypeContext.prototype.INNER = function () {
      return this.getToken(GrammarParser.INNER, 0);
    };

    JointypeContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterJointype(this);
      }
    };

    JointypeContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitJointype(this);
      }
    };

    JointypeContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitJointype(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.JointypeContext = JointypeContext;

    GrammarParser.prototype.jointype = function () {
      var localctx = new JointypeContext(this, this._ctx, this.state);
      this.enterRule(localctx, 72, GrammarParser.RULE_jointype);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 746;
        _la = this._input.LA(1);

        if (!(_la === GrammarParser.LEFT || _la === GrammarParser.INNER)) {
          this._errHandler.recoverInline(this);
        } else {
          this._errHandler.reportMatch(this);

          this.consume();
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MaxmatchdocContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_maxmatchdoc;
      return this;
    }

    MaxmatchdocContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MaxmatchdocContext.prototype.constructor = MaxmatchdocContext;

    MaxmatchdocContext.prototype.MAXMATCH = function () {
      return this.getToken(GrammarParser.MAXMATCH, 0);
    };

    MaxmatchdocContext.prototype.COLON = function () {
      return this.getToken(GrammarParser.COLON, 0);
    };

    MaxmatchdocContext.prototype.INTLIT = function () {
      return this.getToken(GrammarParser.INTLIT, 0);
    };

    MaxmatchdocContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMaxmatchdoc(this);
      }
    };

    MaxmatchdocContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMaxmatchdoc(this);
      }
    };

    MaxmatchdocContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMaxmatchdoc(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MaxmatchdocContext = MaxmatchdocContext;

    GrammarParser.prototype.maxmatchdoc = function () {
      var localctx = new MaxmatchdocContext(this, this._ctx, this.state);
      this.enterRule(localctx, 74, GrammarParser.RULE_maxmatchdoc);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 748;
        this.match(GrammarParser.MAXMATCH);
        this.state = 749;
        this.match(GrammarParser.COLON);
        this.state = 750;
        this.match(GrammarParser.INTLIT);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function OverridefieldContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_overridefield;
      return this;
    }

    OverridefieldContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    OverridefieldContext.prototype.constructor = OverridefieldContext;

    OverridefieldContext.prototype.OVERRIDE = function () {
      return this.getToken(GrammarParser.OVERRIDE, 0);
    };

    OverridefieldContext.prototype.COLON = function () {
      return this.getToken(GrammarParser.COLON, 0);
    };

    OverridefieldContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    OverridefieldContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    OverridefieldContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterOverridefield(this);
      }
    };

    OverridefieldContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitOverridefield(this);
      }
    };

    OverridefieldContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitOverridefield(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.OverridefieldContext = OverridefieldContext;

    GrammarParser.prototype.overridefield = function () {
      var localctx = new OverridefieldContext(this, this._ctx, this.state);
      this.enterRule(localctx, 76, GrammarParser.RULE_overridefield);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 752;
        this.match(GrammarParser.OVERRIDE);
        this.state = 753;
        this.match(GrammarParser.COLON);
        this.state = 754;
        this.match(GrammarParser.STRLIT);
        this.state = 759;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.COMMA) {
          this.state = 755;
          this.match(GrammarParser.COMMA);
          this.state = 756;
          this.match(GrammarParser.STRLIT);
          this.state = 761;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function TableContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_table;
      return this;
    }

    TableContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    TableContext.prototype.constructor = TableContext;

    TableContext.prototype.TABLE = function () {
      return this.getToken(GrammarParser.TABLE, 0);
    };

    TableContext.prototype.list = function () {
      return this.getTypedRuleContext(ListContext, 0);
    };

    TableContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterTable(this);
      }
    };

    TableContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitTable(this);
      }
    };

    TableContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitTable(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.TableContext = TableContext;

    GrammarParser.prototype.table = function () {
      var localctx = new TableContext(this, this._ctx, this.state);
      this.enterRule(localctx, 78, GrammarParser.RULE_table);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 762;
        this.match(GrammarParser.TABLE);
        this.state = 763;
        this.list();
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function ListContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_list;
      return this;
    }

    ListContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    ListContext.prototype.constructor = ListContext;

    ListContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    ListContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    ListContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterList(this);
      }
    };

    ListContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitList(this);
      }
    };

    ListContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitList(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.ListContext = ListContext;

    GrammarParser.prototype.list = function () {
      var localctx = new ListContext(this, this._ctx, this.state);
      this.enterRule(localctx, 80, GrammarParser.RULE_list);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 765;
        this.match(GrammarParser.STRLIT);
        this.state = 770;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.COMMA) {
          this.state = 766;
          this.match(GrammarParser.COMMA);
          this.state = 767;
          this.match(GrammarParser.STRLIT);
          this.state = 772;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function SubqueryContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_subquery;
      return this;
    }

    SubqueryContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    SubqueryContext.prototype.constructor = SubqueryContext;

    SubqueryContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    SubqueryContext.prototype.COLON = function () {
      return this.getToken(GrammarParser.COLON, 0);
    };

    SubqueryContext.prototype.PIPE = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.PIPE);
      } else {
        return this.getToken(GrammarParser.PIPE, i);
      }
    };

    SubqueryContext.prototype.joinexpression = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(JoinexpressionContext);
      } else {
        return this.getTypedRuleContext(JoinexpressionContext, i);
      }
    };

    SubqueryContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterSubquery(this);
      }
    };

    SubqueryContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitSubquery(this);
      }
    };

    SubqueryContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitSubquery(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.SubqueryContext = SubqueryContext;

    GrammarParser.prototype.subquery = function () {
      var localctx = new SubqueryContext(this, this._ctx, this.state);
      this.enterRule(localctx, 82, GrammarParser.RULE_subquery);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 773;
        this.match(GrammarParser.STRLIT);
        this.state = 774;
        this.match(GrammarParser.COLON);
        this.state = 775;
        this.match(GrammarParser.STRLIT);
        this.state = 780;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.PIPE) {
          this.state = 776;
          this.match(GrammarParser.PIPE);
          this.state = 777;
          this.joinexpression();
          this.state = 782;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function ActionContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_action;
      return this;
    }

    ActionContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    ActionContext.prototype.constructor = ActionContext;

    ActionContext.prototype.metrics = function () {
      return this.getTypedRuleContext(MetricsContext, 0);
    };

    ActionContext.prototype.BY = function () {
      return this.getToken(GrammarParser.BY, 0);
    };

    ActionContext.prototype.buckets = function () {
      return this.getTypedRuleContext(BucketsContext, 0);
    };

    ActionContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterAction(this);
      }
    };

    ActionContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitAction(this);
      }
    };

    ActionContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitAction(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.ActionContext = ActionContext;

    GrammarParser.prototype.action = function () {
      var localctx = new ActionContext(this, this._ctx, this.state);
      this.enterRule(localctx, 84, GrammarParser.RULE_action);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 783;
        this.metrics();
        this.state = 784;
        this.match(GrammarParser.BY);
        this.state = 785;
        this.buckets();
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MetricsContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_metrics;
      return this;
    }

    MetricsContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MetricsContext.prototype.constructor = MetricsContext;

    MetricsContext.prototype.metric = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(MetricContext);
      } else {
        return this.getTypedRuleContext(MetricContext, i);
      }
    };

    MetricsContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    MetricsContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMetrics(this);
      }
    };

    MetricsContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMetrics(this);
      }
    };

    MetricsContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMetrics(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MetricsContext = MetricsContext;

    GrammarParser.prototype.metrics = function () {
      var localctx = new MetricsContext(this, this._ctx, this.state);
      this.enterRule(localctx, 86, GrammarParser.RULE_metrics);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 787;
        this.metric();
        this.state = 792;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.COMMA) {
          this.state = 788;
          this.match(GrammarParser.COMMA);
          this.state = 789;
          this.metric();
          this.state = 794;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function MetricContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_metric;
      return this;
    }

    MetricContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    MetricContext.prototype.constructor = MetricContext;

    MetricContext.prototype.METRIC_METHOD = function () {
      return this.getToken(GrammarParser.METRIC_METHOD, 0);
    };

    MetricContext.prototype.LPAREN = function () {
      return this.getToken(GrammarParser.LPAREN, 0);
    };

    MetricContext.prototype.RPAREN = function () {
      return this.getToken(GrammarParser.RPAREN, 0);
    };

    MetricContext.prototype.parameter = function () {
      return this.getTypedRuleContext(ParameterContext, 0);
    };

    MetricContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterMetric(this);
      }
    };

    MetricContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitMetric(this);
      }
    };

    MetricContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitMetric(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.MetricContext = MetricContext;

    GrammarParser.prototype.metric = function () {
      var localctx = new MetricContext(this, this._ctx, this.state);
      this.enterRule(localctx, 88, GrammarParser.RULE_metric);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 795;
        this.match(GrammarParser.METRIC_METHOD);
        this.state = 796;
        this.match(GrammarParser.LPAREN);
        this.state = 798;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        if (_la === GrammarParser.STRLIT) {
          this.state = 797;
          this.parameter();
        }

        this.state = 800;
        this.match(GrammarParser.RPAREN);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function BucketsContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_buckets;
      return this;
    }

    BucketsContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    BucketsContext.prototype.constructor = BucketsContext;

    BucketsContext.prototype.bucket = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(BucketContext);
      } else {
        return this.getTypedRuleContext(BucketContext, i);
      }
    };

    BucketsContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    BucketsContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterBuckets(this);
      }
    };

    BucketsContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitBuckets(this);
      }
    };

    BucketsContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitBuckets(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.BucketsContext = BucketsContext;

    GrammarParser.prototype.buckets = function () {
      var localctx = new BucketsContext(this, this._ctx, this.state);
      this.enterRule(localctx, 90, GrammarParser.RULE_buckets);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 802;
        this.bucket();
        this.state = 807;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.COMMA) {
          this.state = 803;
          this.match(GrammarParser.COMMA);
          this.state = 804;
          this.bucket();
          this.state = 809;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function BucketContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_bucket;
      return this;
    }

    BucketContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    BucketContext.prototype.constructor = BucketContext;

    BucketContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    BucketContext.prototype.LBRACE = function () {
      return this.getToken(GrammarParser.LBRACE, 0);
    };

    BucketContext.prototype.RBRACE = function () {
      return this.getToken(GrammarParser.RBRACE, 0);
    };

    BucketContext.prototype.attributes = function () {
      return this.getTypedRuleContext(AttributesContext, 0);
    };

    BucketContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterBucket(this);
      }
    };

    BucketContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitBucket(this);
      }
    };

    BucketContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitBucket(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.BucketContext = BucketContext;

    GrammarParser.prototype.bucket = function () {
      var localctx = new BucketContext(this, this._ctx, this.state);
      this.enterRule(localctx, 92, GrammarParser.RULE_bucket);
      var _la = 0; // Token type

      try {
        this.state = 817;

        this._errHandler.sync(this);

        var la_ = this._interp.adaptivePredict(this._input, 81, this._ctx);

        switch (la_) {
          case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 810;
            this.match(GrammarParser.STRLIT);
            this.state = 811;
            this.match(GrammarParser.LBRACE);
            this.state = 813;

            this._errHandler.sync(this);

            _la = this._input.LA(1);

            if (_la === GrammarParser.STRLIT) {
              this.state = 812;
              this.attributes();
            }

            this.state = 815;
            this.match(GrammarParser.RBRACE);
            break;

          case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 816;
            this.match(GrammarParser.STRLIT);
            break;
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function AttributesContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_attributes;
      return this;
    }

    AttributesContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    AttributesContext.prototype.constructor = AttributesContext;

    AttributesContext.prototype.attribute = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTypedRuleContexts(AttributeContext);
      } else {
        return this.getTypedRuleContext(AttributeContext, i);
      }
    };

    AttributesContext.prototype.COMMA = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.COMMA);
      } else {
        return this.getToken(GrammarParser.COMMA, i);
      }
    };

    AttributesContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterAttributes(this);
      }
    };

    AttributesContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitAttributes(this);
      }
    };

    AttributesContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitAttributes(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.AttributesContext = AttributesContext;

    GrammarParser.prototype.attributes = function () {
      var localctx = new AttributesContext(this, this._ctx, this.state);
      this.enterRule(localctx, 94, GrammarParser.RULE_attributes);
      var _la = 0; // Token type

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 819;
        this.attribute();
        this.state = 824;

        this._errHandler.sync(this);

        _la = this._input.LA(1);

        while (_la === GrammarParser.COMMA) {
          this.state = 820;
          this.match(GrammarParser.COMMA);
          this.state = 821;
          this.attribute();
          this.state = 826;

          this._errHandler.sync(this);

          _la = this._input.LA(1);
        }
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function AttributeContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_attribute;
      return this;
    }

    AttributeContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    AttributeContext.prototype.constructor = AttributeContext;

    AttributeContext.prototype.STRLIT = function (i) {
      if (i === undefined) {
        i = null;
      }

      if (i === null) {
        return this.getTokens(GrammarParser.STRLIT);
      } else {
        return this.getToken(GrammarParser.STRLIT, i);
      }
    };

    AttributeContext.prototype.ASSIGN = function () {
      return this.getToken(GrammarParser.ASSIGN, 0);
    };

    AttributeContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterAttribute(this);
      }
    };

    AttributeContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitAttribute(this);
      }
    };

    AttributeContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitAttribute(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.AttributeContext = AttributeContext;

    GrammarParser.prototype.attribute = function () {
      var localctx = new AttributeContext(this, this._ctx, this.state);
      this.enterRule(localctx, 96, GrammarParser.RULE_attribute);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 827;
        this.match(GrammarParser.STRLIT);
        this.state = 828;
        this.match(GrammarParser.ASSIGN);
        this.state = 829;
        this.match(GrammarParser.STRLIT);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    function ParameterContext(parser, parent, invokingState) {
      if (parent === undefined) {
        parent = null;
      }

      if (invokingState === undefined || invokingState === null) {
        invokingState = -1;
      }

      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.call(this, parent, invokingState);
      this.parser = parser;
      this.ruleIndex = GrammarParser.RULE_parameter;
      return this;
    }

    ParameterContext.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.ParserRuleContext.prototype);
    ParameterContext.prototype.constructor = ParameterContext;

    ParameterContext.prototype.STRLIT = function () {
      return this.getToken(GrammarParser.STRLIT, 0);
    };

    ParameterContext.prototype.enterRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.enterParameter(this);
      }
    };

    ParameterContext.prototype.exitRule = function (listener) {
      if (listener instanceof GrammarParserListener) {
        listener.exitParameter(this);
      }
    };

    ParameterContext.prototype.accept = function (visitor) {
      if (visitor instanceof GrammarParserVisitor) {
        return visitor.visitParameter(this);
      } else {
        return visitor.visitChildren(this);
      }
    };

    GrammarParser.ParameterContext = ParameterContext;

    GrammarParser.prototype.parameter = function () {
      var localctx = new ParameterContext(this, this._ctx, this.state);
      this.enterRule(localctx, 98, GrammarParser.RULE_parameter);

      try {
        this.enterOuterAlt(localctx, 1);
        this.state = 831;
        this.match(GrammarParser.STRLIT);
      } catch (re) {
        if (re instanceof antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.error.RecognitionException) {
          localctx.exception = re;

          this._errHandler.reportError(this, re);

          this._errHandler.recover(this, re);
        } else {
          throw re;
        }
      } finally {
        this.exitRule();
      }

      return localctx;
    };

    GrammarParser.prototype.sempred = function (localctx, ruleIndex, predIndex) {
      switch (ruleIndex) {
        case 1:
          return this.criterias_sempred(localctx, predIndex);

        default:
          throw "No predicate with index:" + ruleIndex;
      }
    };

    GrammarParser.prototype.criterias_sempred = function (localctx, predIndex) {
      switch (predIndex) {
        case 0:
          return this.precpred(this._ctx, 6);

        default:
          throw "No predicate with index:" + predIndex;
      }
    };
    /* harmony default export */


    __webpack_exports__["default"] = GrammarParser = GrammarParser;
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/antlr/GrammarParserListener.js":
  /*!*******************************************************************!*\
    !*** ./src/app/pages/home/logstab/antlr/GrammarParserListener.js ***!
    \*******************************************************************/

  /*! exports provided: default */

  /***/
  function _src_app_pages_home_logstab_antlr_GrammarParserListenerJs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! antlr4 */
    "./node_modules/antlr4/index.js");
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(antlr4__WEBPACK_IMPORTED_MODULE_0__); // Generated from GrammarParser.g4 by ANTLR 4.8
    // jshint ignore: start
    // This class defines a complete listener for a parse tree produced by GrammarParser.


    function GrammarParserListener() {
      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.tree.ParseTreeListener.call(this);
      return this;
    }

    GrammarParserListener.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.tree.ParseTreeListener.prototype);
    GrammarParserListener.prototype.constructor = GrammarParserListener; // Enter a parse tree produced by GrammarParser#statement.

    GrammarParserListener.prototype.enterStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#statement.


    GrammarParserListener.prototype.exitStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#criterias.


    GrammarParserListener.prototype.enterCriterias = function (ctx) {}; // Exit a parse tree produced by GrammarParser#criterias.


    GrammarParserListener.prototype.exitCriterias = function (ctx) {}; // Enter a parse tree produced by GrammarParser#expression.


    GrammarParserListener.prototype.enterExpression = function (ctx) {}; // Exit a parse tree produced by GrammarParser#expression.


    GrammarParserListener.prototype.exitExpression = function (ctx) {}; // Enter a parse tree produced by GrammarParser#joinexpression.


    GrammarParserListener.prototype.enterJoinexpression = function (ctx) {}; // Exit a parse tree produced by GrammarParser#joinexpression.


    GrammarParserListener.prototype.exitJoinexpression = function (ctx) {}; // Enter a parse tree produced by GrammarParser#instruction.


    GrammarParserListener.prototype.enterInstruction = function (ctx) {}; // Exit a parse tree produced by GrammarParser#instruction.


    GrammarParserListener.prototype.exitInstruction = function (ctx) {}; // Enter a parse tree produced by GrammarParser#methods.


    GrammarParserListener.prototype.enterMethods = function (ctx) {}; // Exit a parse tree produced by GrammarParser#methods.


    GrammarParserListener.prototype.exitMethods = function (ctx) {}; // Enter a parse tree produced by GrammarParser#dedup.


    GrammarParserListener.prototype.enterDedup = function (ctx) {}; // Exit a parse tree produced by GrammarParser#dedup.


    GrammarParserListener.prototype.exitDedup = function (ctx) {}; // Enter a parse tree produced by GrammarParser#whereStatement.


    GrammarParserListener.prototype.enterWhereStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#whereStatement.


    GrammarParserListener.prototype.exitWhereStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#lookupStatement.


    GrammarParserListener.prototype.enterLookupStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#lookupStatement.


    GrammarParserListener.prototype.exitLookupStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#appendStatement.


    GrammarParserListener.prototype.enterAppendStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#appendStatement.


    GrammarParserListener.prototype.exitAppendStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#nomvStatement.


    GrammarParserListener.prototype.enterNomvStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#nomvStatement.


    GrammarParserListener.prototype.exitNomvStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#makemvStatement.


    GrammarParserListener.prototype.enterMakemvStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#makemvStatement.


    GrammarParserListener.prototype.exitMakemvStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#mvcombineStatement.


    GrammarParserListener.prototype.enterMvcombineStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#mvcombineStatement.


    GrammarParserListener.prototype.exitMvcombineStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#mvexpandStatement.


    GrammarParserListener.prototype.enterMvexpandStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#mvexpandStatement.


    GrammarParserListener.prototype.exitMvexpandStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#mvexpandoption.


    GrammarParserListener.prototype.enterMvexpandoption = function (ctx) {}; // Exit a parse tree produced by GrammarParser#mvexpandoption.


    GrammarParserListener.prototype.exitMvexpandoption = function (ctx) {}; // Enter a parse tree produced by GrammarParser#statsStatement.


    GrammarParserListener.prototype.enterStatsStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#statsStatement.


    GrammarParserListener.prototype.exitStatsStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#docStatsStatement.


    GrammarParserListener.prototype.enterDocStatsStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#docStatsStatement.


    GrammarParserListener.prototype.exitDocStatsStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#streamStatsStatement.


    GrammarParserListener.prototype.enterStreamStatsStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#streamStatsStatement.


    GrammarParserListener.prototype.exitStreamStatsStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#statsfield.


    GrammarParserListener.prototype.enterStatsfield = function (ctx) {}; // Exit a parse tree produced by GrammarParser#statsfield.


    GrammarParserListener.prototype.exitStatsfield = function (ctx) {}; // Enter a parse tree produced by GrammarParser#sortStatement.


    GrammarParserListener.prototype.enterSortStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#sortStatement.


    GrammarParserListener.prototype.exitSortStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#mergeStatement.


    GrammarParserListener.prototype.enterMergeStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#mergeStatement.


    GrammarParserListener.prototype.exitMergeStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#mergeoptions.


    GrammarParserListener.prototype.enterMergeoptions = function (ctx) {}; // Exit a parse tree produced by GrammarParser#mergeoptions.


    GrammarParserListener.prototype.exitMergeoptions = function (ctx) {}; // Enter a parse tree produced by GrammarParser#mergeoption.


    GrammarParserListener.prototype.enterMergeoption = function (ctx) {}; // Exit a parse tree produced by GrammarParser#mergeoption.


    GrammarParserListener.prototype.exitMergeoption = function (ctx) {}; // Enter a parse tree produced by GrammarParser#values.


    GrammarParserListener.prototype.enterValues = function (ctx) {}; // Exit a parse tree produced by GrammarParser#values.


    GrammarParserListener.prototype.exitValues = function (ctx) {}; // Enter a parse tree produced by GrammarParser#mergeFields.


    GrammarParserListener.prototype.enterMergeFields = function (ctx) {}; // Exit a parse tree produced by GrammarParser#mergeFields.


    GrammarParserListener.prototype.exitMergeFields = function (ctx) {}; // Enter a parse tree produced by GrammarParser#topStatement.


    GrammarParserListener.prototype.enterTopStatement = function (ctx) {}; // Exit a parse tree produced by GrammarParser#topStatement.


    GrammarParserListener.prototype.exitTopStatement = function (ctx) {}; // Enter a parse tree produced by GrammarParser#topOption.


    GrammarParserListener.prototype.enterTopOption = function (ctx) {}; // Exit a parse tree produced by GrammarParser#topOption.


    GrammarParserListener.prototype.exitTopOption = function (ctx) {}; // Enter a parse tree produced by GrammarParser#topFields.


    GrammarParserListener.prototype.enterTopFields = function (ctx) {}; // Exit a parse tree produced by GrammarParser#topFields.


    GrammarParserListener.prototype.exitTopFields = function (ctx) {}; // Enter a parse tree produced by GrammarParser#sortlimit.


    GrammarParserListener.prototype.enterSortlimit = function (ctx) {}; // Exit a parse tree produced by GrammarParser#sortlimit.


    GrammarParserListener.prototype.exitSortlimit = function (ctx) {}; // Enter a parse tree produced by GrammarParser#number.


    GrammarParserListener.prototype.enterNumber = function (ctx) {}; // Exit a parse tree produced by GrammarParser#number.


    GrammarParserListener.prototype.exitNumber = function (ctx) {}; // Enter a parse tree produced by GrammarParser#unaryOperator.


    GrammarParserListener.prototype.enterUnaryOperator = function (ctx) {}; // Exit a parse tree produced by GrammarParser#unaryOperator.


    GrammarParserListener.prototype.exitUnaryOperator = function (ctx) {}; // Enter a parse tree produced by GrammarParser#unsignedNumber.


    GrammarParserListener.prototype.enterUnsignedNumber = function (ctx) {}; // Exit a parse tree produced by GrammarParser#unsignedNumber.


    GrammarParserListener.prototype.exitUnsignedNumber = function (ctx) {}; // Enter a parse tree produced by GrammarParser#floatVal.


    GrammarParserListener.prototype.enterFloatVal = function (ctx) {}; // Exit a parse tree produced by GrammarParser#floatVal.


    GrammarParserListener.prototype.exitFloatVal = function (ctx) {}; // Enter a parse tree produced by GrammarParser#fetchlogQuery.


    GrammarParserListener.prototype.enterFetchlogQuery = function (ctx) {}; // Exit a parse tree produced by GrammarParser#fetchlogQuery.


    GrammarParserListener.prototype.exitFetchlogQuery = function (ctx) {}; // Enter a parse tree produced by GrammarParser#indexpattern.


    GrammarParserListener.prototype.enterIndexpattern = function (ctx) {}; // Exit a parse tree produced by GrammarParser#indexpattern.


    GrammarParserListener.prototype.exitIndexpattern = function (ctx) {}; // Enter a parse tree produced by GrammarParser#join.


    GrammarParserListener.prototype.enterJoin = function (ctx) {}; // Exit a parse tree produced by GrammarParser#join.


    GrammarParserListener.prototype.exitJoin = function (ctx) {}; // Enter a parse tree produced by GrammarParser#jointype.


    GrammarParserListener.prototype.enterJointype = function (ctx) {}; // Exit a parse tree produced by GrammarParser#jointype.


    GrammarParserListener.prototype.exitJointype = function (ctx) {}; // Enter a parse tree produced by GrammarParser#maxmatchdoc.


    GrammarParserListener.prototype.enterMaxmatchdoc = function (ctx) {}; // Exit a parse tree produced by GrammarParser#maxmatchdoc.


    GrammarParserListener.prototype.exitMaxmatchdoc = function (ctx) {}; // Enter a parse tree produced by GrammarParser#overridefield.


    GrammarParserListener.prototype.enterOverridefield = function (ctx) {}; // Exit a parse tree produced by GrammarParser#overridefield.


    GrammarParserListener.prototype.exitOverridefield = function (ctx) {}; // Enter a parse tree produced by GrammarParser#table.


    GrammarParserListener.prototype.enterTable = function (ctx) {}; // Exit a parse tree produced by GrammarParser#table.


    GrammarParserListener.prototype.exitTable = function (ctx) {}; // Enter a parse tree produced by GrammarParser#list.


    GrammarParserListener.prototype.enterList = function (ctx) {}; // Exit a parse tree produced by GrammarParser#list.


    GrammarParserListener.prototype.exitList = function (ctx) {}; // Enter a parse tree produced by GrammarParser#subquery.


    GrammarParserListener.prototype.enterSubquery = function (ctx) {}; // Exit a parse tree produced by GrammarParser#subquery.


    GrammarParserListener.prototype.exitSubquery = function (ctx) {}; // Enter a parse tree produced by GrammarParser#action.


    GrammarParserListener.prototype.enterAction = function (ctx) {}; // Exit a parse tree produced by GrammarParser#action.


    GrammarParserListener.prototype.exitAction = function (ctx) {}; // Enter a parse tree produced by GrammarParser#metrics.


    GrammarParserListener.prototype.enterMetrics = function (ctx) {}; // Exit a parse tree produced by GrammarParser#metrics.


    GrammarParserListener.prototype.exitMetrics = function (ctx) {}; // Enter a parse tree produced by GrammarParser#metric.


    GrammarParserListener.prototype.enterMetric = function (ctx) {}; // Exit a parse tree produced by GrammarParser#metric.


    GrammarParserListener.prototype.exitMetric = function (ctx) {}; // Enter a parse tree produced by GrammarParser#buckets.


    GrammarParserListener.prototype.enterBuckets = function (ctx) {}; // Exit a parse tree produced by GrammarParser#buckets.


    GrammarParserListener.prototype.exitBuckets = function (ctx) {}; // Enter a parse tree produced by GrammarParser#bucket.


    GrammarParserListener.prototype.enterBucket = function (ctx) {}; // Exit a parse tree produced by GrammarParser#bucket.


    GrammarParserListener.prototype.exitBucket = function (ctx) {}; // Enter a parse tree produced by GrammarParser#attributes.


    GrammarParserListener.prototype.enterAttributes = function (ctx) {}; // Exit a parse tree produced by GrammarParser#attributes.


    GrammarParserListener.prototype.exitAttributes = function (ctx) {}; // Enter a parse tree produced by GrammarParser#attribute.


    GrammarParserListener.prototype.enterAttribute = function (ctx) {}; // Exit a parse tree produced by GrammarParser#attribute.


    GrammarParserListener.prototype.exitAttribute = function (ctx) {}; // Enter a parse tree produced by GrammarParser#parameter.


    GrammarParserListener.prototype.enterParameter = function (ctx) {}; // Exit a parse tree produced by GrammarParser#parameter.


    GrammarParserListener.prototype.exitParameter = function (ctx) {};
    /* harmony default export */


    __webpack_exports__["default"] = GrammarParserListener = GrammarParserListener;
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/antlr/GrammarParserVisitor.js":
  /*!******************************************************************!*\
    !*** ./src/app/pages/home/logstab/antlr/GrammarParserVisitor.js ***!
    \******************************************************************/

  /*! exports provided: default */

  /***/
  function _src_app_pages_home_logstab_antlr_GrammarParserVisitorJs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! antlr4 */
    "./node_modules/antlr4/index.js");
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(antlr4__WEBPACK_IMPORTED_MODULE_0__); // Generated from GrammarParser.g4 by ANTLR 4.8
    // jshint ignore: start
    // This class defines a complete generic visitor for a parse tree produced by GrammarParser.


    function GrammarParserVisitor() {
      antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.tree.ParseTreeVisitor.call(this);
      return this;
    }

    GrammarParserVisitor.prototype = Object.create(antlr4__WEBPACK_IMPORTED_MODULE_0___default.a.tree.ParseTreeVisitor.prototype);
    GrammarParserVisitor.prototype.constructor = GrammarParserVisitor; // Visit a parse tree produced by GrammarParser#statement.

    GrammarParserVisitor.prototype.visitStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#criterias.


    GrammarParserVisitor.prototype.visitCriterias = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#expression.


    GrammarParserVisitor.prototype.visitExpression = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#joinexpression.


    GrammarParserVisitor.prototype.visitJoinexpression = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#instruction.


    GrammarParserVisitor.prototype.visitInstruction = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#methods.


    GrammarParserVisitor.prototype.visitMethods = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#dedup.


    GrammarParserVisitor.prototype.visitDedup = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#whereStatement.


    GrammarParserVisitor.prototype.visitWhereStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#lookupStatement.


    GrammarParserVisitor.prototype.visitLookupStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#appendStatement.


    GrammarParserVisitor.prototype.visitAppendStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#nomvStatement.


    GrammarParserVisitor.prototype.visitNomvStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#makemvStatement.


    GrammarParserVisitor.prototype.visitMakemvStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#mvcombineStatement.


    GrammarParserVisitor.prototype.visitMvcombineStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#mvexpandStatement.


    GrammarParserVisitor.prototype.visitMvexpandStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#mvexpandoption.


    GrammarParserVisitor.prototype.visitMvexpandoption = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#statsStatement.


    GrammarParserVisitor.prototype.visitStatsStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#docStatsStatement.


    GrammarParserVisitor.prototype.visitDocStatsStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#streamStatsStatement.


    GrammarParserVisitor.prototype.visitStreamStatsStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#statsfield.


    GrammarParserVisitor.prototype.visitStatsfield = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#sortStatement.


    GrammarParserVisitor.prototype.visitSortStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#mergeStatement.


    GrammarParserVisitor.prototype.visitMergeStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#mergeoptions.


    GrammarParserVisitor.prototype.visitMergeoptions = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#mergeoption.


    GrammarParserVisitor.prototype.visitMergeoption = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#values.


    GrammarParserVisitor.prototype.visitValues = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#mergeFields.


    GrammarParserVisitor.prototype.visitMergeFields = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#topStatement.


    GrammarParserVisitor.prototype.visitTopStatement = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#topOption.


    GrammarParserVisitor.prototype.visitTopOption = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#topFields.


    GrammarParserVisitor.prototype.visitTopFields = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#sortlimit.


    GrammarParserVisitor.prototype.visitSortlimit = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#number.


    GrammarParserVisitor.prototype.visitNumber = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#unaryOperator.


    GrammarParserVisitor.prototype.visitUnaryOperator = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#unsignedNumber.


    GrammarParserVisitor.prototype.visitUnsignedNumber = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#floatVal.


    GrammarParserVisitor.prototype.visitFloatVal = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#fetchlogQuery.


    GrammarParserVisitor.prototype.visitFetchlogQuery = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#indexpattern.


    GrammarParserVisitor.prototype.visitIndexpattern = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#join.


    GrammarParserVisitor.prototype.visitJoin = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#jointype.


    GrammarParserVisitor.prototype.visitJointype = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#maxmatchdoc.


    GrammarParserVisitor.prototype.visitMaxmatchdoc = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#overridefield.


    GrammarParserVisitor.prototype.visitOverridefield = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#table.


    GrammarParserVisitor.prototype.visitTable = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#list.


    GrammarParserVisitor.prototype.visitList = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#subquery.


    GrammarParserVisitor.prototype.visitSubquery = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#action.


    GrammarParserVisitor.prototype.visitAction = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#metrics.


    GrammarParserVisitor.prototype.visitMetrics = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#metric.


    GrammarParserVisitor.prototype.visitMetric = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#buckets.


    GrammarParserVisitor.prototype.visitBuckets = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#bucket.


    GrammarParserVisitor.prototype.visitBucket = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#attributes.


    GrammarParserVisitor.prototype.visitAttributes = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#attribute.


    GrammarParserVisitor.prototype.visitAttribute = function (ctx) {
      return this.visitChildren(ctx);
    }; // Visit a parse tree produced by GrammarParser#parameter.


    GrammarParserVisitor.prototype.visitParameter = function (ctx) {
      return this.visitChildren(ctx);
    };
    /* harmony default export */


    __webpack_exports__["default"] = GrammarParserVisitor = GrammarParserVisitor;
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/antlr/index.js":
  /*!***************************************************!*\
    !*** ./src/app/pages/home/logstab/antlr/index.js ***!
    \***************************************************/

  /*! exports provided: parse */

  /***/
  function _src_app_pages_home_logstab_antlr_indexJs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "parse", function () {
      return parse;
    });
    /* harmony import */


    var _GrammarLexer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! ./GrammarLexer */
    "./src/app/pages/home/logstab/antlr/GrammarLexer.js");
    /* harmony import */


    var _GrammarParser__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
    /*! ./GrammarParser */
    "./src/app/pages/home/logstab/antlr/GrammarParser.js");
    /* harmony import */


    var antlr4_autosuggest__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(
    /*! antlr4-autosuggest */
    "./node_modules/antlr4-autosuggest/antlr4-autosuggest.js");
    /* harmony import */


    var antlr4_autosuggest__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(antlr4_autosuggest__WEBPACK_IMPORTED_MODULE_2__);
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(
    /*! antlr4 */
    "./node_modules/antlr4/index.js");
    /* harmony import */


    var antlr4__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(antlr4__WEBPACK_IMPORTED_MODULE_3__);

    function parse(input, val) {
      input = input.replace(/[\s\u00A0]/g, ' ');

      if (input.endsWith("AND") || input.endsWith("NOT") || input.endsWith("OR")) {
        input = input + " ";
      }

      console.log(input);
      var query = {
        statements: []
      };
      var chars = new antlr4__WEBPACK_IMPORTED_MODULE_3___default.a.InputStream(input);
      var lexer = new _GrammarLexer__WEBPACK_IMPORTED_MODULE_0__["default"](chars);
      var tokens = new antlr4__WEBPACK_IMPORTED_MODULE_3___default.a.CommonTokenStream(lexer);
      var parser = new _GrammarParser__WEBPACK_IMPORTED_MODULE_1__["default"](tokens);
      var autosuggester = antlr4_autosuggest__WEBPACK_IMPORTED_MODULE_2___default.a.autosuggester(_GrammarLexer__WEBPACK_IMPORTED_MODULE_0__["default"], _GrammarParser__WEBPACK_IMPORTED_MODULE_1__["default"]);
      var suggestions = autosuggester.autosuggest(input);
      parser.buildParseTrees = true;

      try {// antlr4.tree.ParseTreeWalker.DEFAULT.walk(printer, tree);
      } catch (e) {
        console.log(e);
      }

      return {
        suggestion: suggestions
      };
    }
    /***/

  },

  /***/
  "./src/app/pages/home/logstab/log-exceptions/log-exceptions.component.scss":
  /*!*********************************************************************************!*\
    !*** ./src/app/pages/home/logstab/log-exceptions/log-exceptions.component.scss ***!
    \*********************************************************************************/

  /*! exports provided: default */

  /***/
  function _src_app_pages_home_logstab_logExceptions_logExceptionsComponentScss(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony default export */


    __webpack_exports__["default"] = ".selected-row {\n  background-color: rgba(83, 183, 113, 0.4) !important;\n}";
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/log-exceptions/log-exceptions.component.ts":
  /*!*******************************************************************************!*\
    !*** ./src/app/pages/home/logstab/log-exceptions/log-exceptions.component.ts ***!
    \*******************************************************************************/

  /*! exports provided: LogExceptionsComponent */

  /***/
  function _src_app_pages_home_logstab_logExceptions_logExceptionsComponentTs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "LogExceptionsComponent", function () {
      return LogExceptionsComponent;
    });
    /* harmony import */


    var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! tslib */
    "./node_modules/tslib/tslib.es6.js");
    /* harmony import */


    var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
    /*! @angular/core */
    "./node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js");
    /* harmony import */


    var src_app_shared_time_bar_service_time_bar_service__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(
    /*! src/app/shared/time-bar/service/time-bar.service */
    "./src/app/shared/time-bar/service/time-bar.service.ts");
    /* harmony import */


    var _create_visualization_service_visualization_service__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(
    /*! ../../../create-visualization/service/visualization.service */
    "./src/app/pages/create-visualization/service/visualization.service.ts");
    /* harmony import */


    var src_app_core_session_session_service__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(
    /*! src/app/core/session/session.service */
    "./src/app/core/session/session.service.ts");
    /* harmony import */


    var _create_visualization_service_visualization_state__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(
    /*! ../../../create-visualization/service/visualization-state */
    "./src/app/pages/create-visualization/service/visualization-state.ts");
    /* harmony import */


    var uuid__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(
    /*! uuid */
    "./node_modules/uuid/dist/esm-browser/index.js");
    /* harmony import */


    var _service_nf_logs_service__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(
    /*! ../service/nf-logs.service */
    "./src/app/pages/home/logstab/service/nf-logs.service.ts");

    var LogExceptionsComponent = /*#__PURE__*/function () {
      function LogExceptionsComponent(timebarService, vis, sessionService, el, nf) {
        _classCallCheck(this, LogExceptionsComponent);

        this.timebarService = timebarService;
        this.vis = vis;
        this.sessionService = sessionService;
        this.el = el;
        this.nf = nf;
        this.sorting = 'desc';
        this.hitsvalue_exception = new _angular_core__WEBPACK_IMPORTED_MODULE_1__["EventEmitter"]();
        this.exception_Obj = new _angular_core__WEBPACK_IMPORTED_MODULE_1__["EventEmitter"]();
        this.showExceptionProgressBar = new _angular_core__WEBPACK_IMPORTED_MODULE_1__["EventEmitter"]();
        this.disableclearsearchbutton = new _angular_core__WEBPACK_IMPORTED_MODULE_1__["EventEmitter"]();
        this.cancelExceptionReq = new _angular_core__WEBPACK_IMPORTED_MODULE_1__["EventEmitter"]();
        this.disableCancelButton = new _angular_core__WEBPACK_IMPORTED_MODULE_1__["EventEmitter"]();
        this.exceptionTableResponse = new _angular_core__WEBPACK_IMPORTED_MODULE_1__["EventEmitter"]();
        this.prevQueryChart = '';
        this.exceptionChartLoading = false; //it is use for chart spinner

        this.exceptionTableData = [];
        this.logTableData = [];
        this.exceptionFirstOccurrence = [];
        this.exceptionCount = [];
        this.exceptionName = '';
        this.logType = '';
        this.selectedRow = false;
        this.pipetemindexvalue = true;
        this.metricAggregation = [{
          id: '1',
          aggType: 'count',
          queryAggType: 'count',
          field: '',
          metfield: {
            label: 'Count'
          },
          metAgg: {
            label: 'Count'
          },
          isMetricFieldAgg: false,
          customName: 'count'
        }];
        this.bucketAggregation = [{
          id: '2',
          aggType: 'terms',
          field: 'exceptiontype',
          buckfield: {
            label: 'exceptiontype',
            value: 'exceptiontype'
          },
          buckAgg: {
            label: 'Terms'
          },
          interval: this.timebarService.getValue().viewBy.selected.id + 's',
          isDateBucket: true,
          customName: 'exceptiontype'
        }, {
          id: '3',
          aggType: 'terms',
          field: 'loglevel',
          buckfield: {
            label: 'loglevel',
            value: 'loglevel'
          },
          buckAgg: {
            label: 'Terms'
          },
          interval: this.timebarService.getValue().viewBy.selected.id + 's',
          isDateBucket: true,
          customName: 'loglevel'
        }];
        this.chartBucketAggregation = [{
          id: '2',
          aggType: 'terms',
          field: '@timestamp',
          buckfield: {
            label: '@timestamp',
            value: '@timestamp'
          },
          buckAgg: {
            label: 'Terms'
          },
          interval: this.timebarService.getValue().viewBy.selected.id + 's',
          isDateBucket: true,
          customName: '@timestamp'
        }];
        this.highlightedRow = {
          exceptionType: '',
          logLevel: ''
        };
        this.isRequestCancel = true;
        this.noData = false; // it is use for when no data is available

        this.XaxisData = [];
        this.showGraph = 0;
        this.tableRequestStatus = '';
        this.mostFrequent = [{
          label: 'Most Recent',
          value: 'recent'
        }, {
          label: 'Most Frequent',
          value: 'frequent'
        }];
        this.exceptionTableHeader = [{
          field: 'Exception',
          header: 'Exception'
        }, {
          field: 'Log',
          header: 'Log Types'
        }, {
          field: 'count',
          header: 'Count'
        }, {
          field: 'FirstOccurence',
          header: 'First Occurence'
        }, {
          field: 'Last Seen',
          header: 'Last Seen'
        }];
        this.logDataTableHeader = [{
          field: 'Fields',
          header: 'Fields'
        }, {
          field: 'Value',
          header: 'Value'
        }];
      }

      return _createClass(LogExceptionsComponent, [{
        key: "ngOnInit",
        value: function ngOnInit() {}
      }, {
        key: "ngOnChanges",
        value: function ngOnChanges(changes) {
          var _this = this;

          if (window['logLevel'] > 0) {
            console.log("changes::::::::", changes);
          } //below code is use for send the request of query setting when you click on exception section


          if (Object.keys(changes).includes('switchTab') && changes.switchTab.currentValue == 'exception') {
            this.onqueryDataLoaded();
          }

          if (this.switchTab == 'exception') {
            this.exceptionTableLoading = true;
            this.hitsvalue_exception.emit({
              data: 0
            });
            this.noData = false;

            if (Object.keys(changes).includes('onClickCancel')) {
              if (changes.onClickCancel.currentValue == true) {
                //it is cancel the exception table request when hitting the cancel button
                if (this.isRequestCancel == false && this.requestUUID != null) {
                  this.cancelTableQuery(this.requestUUID, this.query, this.bucketAggregation);
                  this.isRequestCancel = true;
                  this.requestUUID = null;
                } //it is cancel the chart request 


                if (this.chart_previous_request_id != null && this.prevQueryChart != "") {
                  this.cancelTableQuery(this.chart_previous_request_id, this.prevQueryChart, this.chartBucketAggregation);
                  this.prevQueryChart = "";
                  this.chart_previous_request_id = null;
                  this.chart_requestUUID = null;
                } //reset cancel


                this.cancelExceptionReq.emit({
                  cancelReq: false
                });
              } else {
                if (this.exceptionTableData.length == 0) {
                  this.exceptionTableLoading = false;
                  this.noData = true;
                }
              }
            } else {
              //when changing the query the previous query should be cancelled  then execute new query
              if (Object.keys(changes).includes('query') && Object.keys(changes).includes('switchTab') == false && changes.query.currentValue.includes('index=')) {
                this.indexpattern = this.query.split(" ")[0].split("=")[1];
                this.query = this.query.substr(this.query.indexOf("query=") + 6, this.query.length);
              } // if we are not passing index in the search bar then index=*


              if (Object.keys(changes).includes('query') && Object.keys(changes).includes('switchTab') == false && changes.query.currentValue.includes('index=') == false) {
                this.indexpattern = '*';
              } //cancel the exception table request when search a new query


              if (this.isRequestCancel == false && this.requestUUID != null) {
                clearTimeout(this.timer);
                this.cancelTableQuery(this.requestUUID, this.query, this.bucketAggregation);
              }

              this.selectMostFrequent = '';
              this.exceptionTableData = [];
              this.logTableData = [];
              this.selectedRow = false;

              if (document.getElementById('chartContainer')) {
                document.getElementById('chartContainer').style.display = 'none';
              } //send new request


              setTimeout(function () {
                _this.executeExceptionTable();
              }, 500);
            }
          }

          if (this.switchTab == 'logs') {
            //to stop extra cancel request in logstab
            this.isRequestCancel = true; //cancel the exception table request when switch the tab

            if (this.requestUUID != null) {
              if (this.query.includes("query=")) {
                this.query = this.query.substr(this.query.indexOf("query=") + 6, this.query.length);
              }

              this.cancelTableQuery(this.requestUUID, this.query, this.bucketAggregation);
            } //cancel the chart request


            if (this.chart_previous_request_id != null) {
              this.cancelTableQuery(this.chart_previous_request_id, this.prevQueryChart, this.chartBucketAggregation);
            }

            this.requestUUID = null;
            this.chart_previous_request_id = null;
            this.selectMostFrequent = '';
            this.exceptionTableData = [];
            this.logTableData = [];
            this.selectedRow = false;
            this.prevQueryChart = "";
            this.chart_previous_request_id = null;

            if (document.getElementById('chartContainer')) {
              document.getElementById('chartContainer').style.display = 'none';
            }
          }
        } //querysetting request 

      }, {
        key: "onqueryDataLoaded",
        value: function onqueryDataLoaded() {
          var _this2 = this;

          var me = this;
          me.querySettingsdata.forEach(function (element) {
            if (element.name == "query_log_level") {
              _this2.queryLogLevel = element.value;
            }

            if (element.name == "page_size") {
              _this2.pageSize = element.value;
            }

            if (element.name == "query_window_size") {
              _this2.qureyWindowSize = element.value;
            }

            if (element.name == "query_progress_update_interval") {
              _this2.queryProgressUpdateInterval = element.value;
            }

            if (element.name == "sort:options") {
              _this2.sortoptionsvalue = element.value;
            }
          });
        }
      }, {
        key: "cancelTableQuery",
        value: function cancelTableQuery(reqId, query, buckAgg) {
          var _this3 = this;

          var querycontext = {
            "request_id": reqId,
            "query_win_size": this.qureyWindowSize,
            "query_start_time": this.gte,
            "query_op": "Cancel",
            "log_level": this.queryLogLevel
          };
          var winNumObj = {
            "sendDoc": "true",
            "page_num": 0,
            "page_size": this.pageSize
          };
          this.tableRequestStatus = 'Cancelled';
          this.disableclearsearchbutton.emit({
            searchClearIcon: false
          });
          this.showExceptionProgressBar.emit({
            showProgressBar: false
          });
          this.vis.visualization(query, this.indexpattern, this.gte, this.lte, this.sorting, this.metricAggregation, buckAgg, sessionStorage.getItem('_nvtimezone'), this.pipetemindexvalue, this.sourceformatvalue.toString(), 50, this.responseformat, querycontext, winNumObj, this.sortoptionsvalue).subscribe(function (state) {
            if (state instanceof _create_visualization_service_visualization_state__WEBPACK_IMPORTED_MODULE_5__["visualLoadingState"]) {
              _this3.isRequestCancel = true;
              return;
            }

            if (state instanceof _create_visualization_service_visualization_state__WEBPACK_IMPORTED_MODULE_5__["visualLoadedState"]) {
              return;
            }
          });
        }
      }, {
        key: "getRequestId",
        value: function getRequestId() {
          return Object(uuid__WEBPACK_IMPORTED_MODULE_6__["v4"])();
        } //sending execute request when you click on exception tab

      }, {
        key: "executeExceptionTable",
        value: function executeExceptionTable() {
          var _this4 = this;

          var _a;

          var me = this;
          this.showGraph = 0;

          if (((_a = me.querySettingsdata) === null || _a === void 0 ? void 0 : _a.length) != 0) {
            this.requestUUID = this.getRequestId();
            this.query_op = 'Execute';
            var querycontext = {
              "request_id": this.requestUUID,
              "query_win_size": this.qureyWindowSize,
              "query_start_time": this.gte,
              "query_op": this.query_op,
              "log_level": this.queryLogLevel
            };
            var winNumObj = {
              "sendDoc": "true",
              "page_num": 0,
              "page_size": this.pageSize
            };
            this.isRequestCancel = false;
            this.showExceptionProgressBar.emit({
              showProgressBar: true
            });
            this.disableclearsearchbutton.emit({
              searchClearIcon: true
            });
            this.exception_Obj.emit({
              processedCount: 0,
              totalCount: 0
            });
            this.disableCancelButton.emit({
              cancelIcon: true
            });
            this.vis.visualization(this.query, this.indexpattern, this.gte, this.lte, this.sorting, this.metricAggregation, this.bucketAggregation, sessionStorage.getItem('_nvtimezone'), this.pipetemindexvalue, this.sourceformatvalue.toString(), 50, this.responseformat, querycontext, winNumObj, this.sortoptionsvalue).subscribe(function (state) {
              if (state instanceof _create_visualization_service_visualization_state__WEBPACK_IMPORTED_MODULE_5__["visualLoadedState"]) {
                setTimeout(function () {
                  _this4.getMsearchData(state);
                }, _this4.queryProgressUpdateInterval);
                return;
              }

              return;
            });
          }
        } //sending update progress request for exception table 

      }, {
        key: "getMsearchData",
        value: function getMsearchData(state) {
          var _this5 = this;

          var resp = state === null || state === void 0 ? void 0 : state.data;
          this.query_op = 'UpdateProgress';
          var querycontext = {
            "request_id": this.requestUUID,
            "query_win_size": this.qureyWindowSize,
            "query_start_time": this.gte,
            "query_op": this.query_op,
            "log_level": this.queryLogLevel
          };
          var winNumObj = {
            "sendDoc": true,
            "page_num": 0,
            "page_size": this.pageSize
          };

          if (this.isRequestCancel == false && this.requestUUID != null) {
            this.vis.visualization(this.query, this.indexpattern, this.gte, this.lte, this.sorting, this.metricAggregation, this.bucketAggregation, sessionStorage.getItem('_nvtimezone'), this.pipetemindexvalue, this.sourceformatvalue.toString(), 50, this.responseformat, querycontext, winNumObj, this.sortoptionsvalue).subscribe(function (state) {
              var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;

              if (state instanceof _create_visualization_service_visualization_state__WEBPACK_IMPORTED_MODULE_5__["visualLoadedState"]) {
                if ((state === null || state === void 0 ? void 0 : state.data) != undefined) {
                  _this5.exceptionTableResponse.emit({
                    data: state === null || state === void 0 ? void 0 : state.data
                  });

                  if (((_b = (_a = state === null || state === void 0 ? void 0 : state.data['0']) === null || _a === void 0 ? void 0 : _a.QueryContext) === null || _b === void 0 ? void 0 : _b.QueryOP) != 'Execute') {
                    _this5.exception_Obj.emit({
                      processedCount: (_d = (_c = state === null || state === void 0 ? void 0 : state.data[0]) === null || _c === void 0 ? void 0 : _c.streamStatistics) === null || _d === void 0 ? void 0 : _d.processedCount,
                      totalCount: (_f = (_e = state === null || state === void 0 ? void 0 : state.data[0]) === null || _e === void 0 ? void 0 : _e.streamStatistics) === null || _f === void 0 ? void 0 : _f.totalCount
                    });
                  }

                  _this5.tableRequestStatus = (_h = (_g = state === null || state === void 0 ? void 0 : state.data['0']) === null || _g === void 0 ? void 0 : _g.QueryContext) === null || _h === void 0 ? void 0 : _h.QueryStatus;
                } //check for cancel when tabledata is empty


                if (((_j = state === null || state === void 0 ? void 0 : state.data[0]) === null || _j === void 0 ? void 0 : _j.tableData.length) == 0 && _this5.chart_previous_request_id != null && _this5.prevQueryChart != "" && ((_l = (_k = state === null || state === void 0 ? void 0 : state.data['0']) === null || _k === void 0 ? void 0 : _k.QueryContext) === null || _l === void 0 ? void 0 : _l.QueryStatus) == 'Completed' && _this5.exceptionTableData.length == 0) {
                  //for a invalid query we set hitsvalue is 0
                  _this5.hitsvalue_exception.emit({
                    data: 0
                  });

                  _this5.cancelTableQuery(_this5.chart_previous_request_id, _this5.prevQueryChart, _this5.chartBucketAggregation);

                  _this5.chart_previous_request_id = null;
                  _this5.prevQueryChart = "";
                }

                if ((state === null || state === void 0 ? void 0 : state.data) && (state === null || state === void 0 ? void 0 : state.data.length) > 0) {
                  if (((_m = state === null || state === void 0 ? void 0 : state.data[0]) === null || _m === void 0 ? void 0 : _m.tableData.length) != 0) {
                    _this5.selectedRow = true;
                    _this5.showGraph = _this5.showGraph + 1;
                    _this5.exceptionTableData = (_o = state === null || state === void 0 ? void 0 : state.data[0]) === null || _o === void 0 ? void 0 : _o.tableData; //convert timestamp of first occurence and lastseen in  exception table

                    _this5.exceptionTableData.forEach(function (element) {
                      for (var i in element) {
                        if (Object.prototype.hasOwnProperty.call(element, i)) {
                          if (i === 'first_occurence' || i === 'last_seen') {
                            element[i] = _this5.sessionService.convertTimestampIntoFormattedString(element[i], 'MM/DD/YYYY HH:mm:ss');
                          }
                        }
                      }
                    }); //execute chart request for first time after loading the table


                    if (_this5.showGraph == 1) {
                      _this5.executeRowClick(_this5.exceptionTableData[0], 0);

                      _this5.disableCancelButton.emit({
                        cancelIcon: false
                      });
                    }
                  }
                }

                if (((_q = (_p = state === null || state === void 0 ? void 0 : state.data['0']) === null || _p === void 0 ? void 0 : _p.QueryContext) === null || _q === void 0 ? void 0 : _q.QueryStatus) == 'Processing') {
                  _this5.showExceptionProgressBar.emit({
                    showProgressBar: true
                  });

                  _this5.disableclearsearchbutton.emit({
                    searchClearIcon: true
                  });

                  if (((_r = state === null || state === void 0 ? void 0 : state.data[0]) === null || _r === void 0 ? void 0 : _r.tableData.length) != 0) {
                    _this5.exceptionTableLoading = false;
                  }

                  _this5.timer = setTimeout(function () {
                    _this5.getMsearchData(state);
                  }, _this5.queryProgressUpdateInterval);
                } //for no data available


                if (((_t = (_s = state === null || state === void 0 ? void 0 : state.data['0']) === null || _s === void 0 ? void 0 : _s.QueryContext) === null || _t === void 0 ? void 0 : _t.QueryStatus) == 'Completed') {
                  _this5.disableCancelButton.emit({
                    cancelIcon: false
                  });

                  _this5.disableclearsearchbutton.emit({
                    searchClearIcon: false
                  });

                  _this5.showExceptionProgressBar.emit({
                    showProgressBar: false
                  });

                  if (((_u = state === null || state === void 0 ? void 0 : state.data[0]) === null || _u === void 0 ? void 0 : _u.tableData.length) == 0 && _this5.exceptionTableData.length == 0) {
                    _this5.exceptionTableLoading = false;
                    _this5.noData = true;
                  }
                }

                _this5.selectMostFrequent = 'recent';

                _this5.sortDataDescending();
              }

              return;
            });
          }
        } //functionality of most recent and most frequent buttons

      }, {
        key: "sortDataDescending",
        value: function sortDataDescending() {
          if (this.selectMostFrequent === 'recent') {
            this.exceptionTableData.sort(function (a, b) {
              return b.last_seen < a.last_seen ? -1 : 1;
            });
          } else if (this.selectMostFrequent === 'frequent') {
            this.exceptionTableData.sort(function (a, b) {
              var countA = parseInt(a["count 0"].replace(",", ""));
              var countB = parseInt(b["count 0"].replace(",", ""));
              return countB - countA;
            });
          }
        } // below function is used for sending execute request for chart.

      }, {
        key: "executeRowClick",
        value: function executeRowClick(row, i) {
          var _this6 = this;

          // this.highlightedRow = row.exceptiontype;
          this.highlightedRow.exceptionType = row.exceptiontype;
          this.highlightedRow.logLevel = row.loglevel; //check cancel request for chart request id is null or not

          if (this.chart_previous_request_id != null && this.prevQueryChart != "") {
            this.cancelTableQuery(this.chart_previous_request_id, this.prevQueryChart, this.chartBucketAggregation);
          }

          this.exceptionChartLoading = true;
          this.logTableData = [];
          this.chartContainer = document.getElementById('chartContainer');

          if (this.chartContainer) {
            this.chartContainer.style.display = 'none';
          }

          this.chart_requestUUID = this.getRequestId();
          this.chart_previous_request_id = this.chart_requestUUID;

          if (this.query.startsWith('*') && this.query != '*') {
            this.prevQueryChart = "exceptiontype:" + row.exceptiontype + " AND " + "loglevel:" + row.loglevel + this.query.substring(1);
          } else {
            this.prevQueryChart = "exceptiontype:" + row.exceptiontype + " AND " + "loglevel:" + row.loglevel + " AND " + this.query;
          }

          this.chart_query_op = 'Execute';
          var querycontext = {
            "request_id": this.chart_requestUUID,
            "query_win_size": this.qureyWindowSize,
            "query_start_time": this.gte,
            "query_op": this.chart_query_op,
            "log_level": this.queryLogLevel
          };
          var winNumObj = {
            "sendDoc": "true",
            "page_num": 0,
            "page_size": this.pageSize
          };

          if (this.showGraph > 1) {
            this.exception_Obj.emit({
              processedCount: 0,
              totalCount: 0
            });
          }

          this.showExceptionProgressBar.emit({
            showProgressBar: true
          });

          if (this.chart_requestUUID != "" && this.chart_requestUUID != null) {
            this.vis.visualization(this.prevQueryChart, this.indexpattern, this.gte, this.lte, this.sorting, this.metricAggregation, this.chartBucketAggregation, sessionStorage.getItem('_nvtimezone'), this.pipetemindexvalue, this.sourceformatvalue.toString(), 50, this.responseformat, querycontext, winNumObj, this.sortoptionsvalue).subscribe(function (state) {
              if (state instanceof _create_visualization_service_visualization_state__WEBPACK_IMPORTED_MODULE_5__["visualLoadedState"]) {
                setTimeout(function () {
                  _this6.rowClick(state, row, i);
                }, _this6.queryProgressUpdateInterval);
                return;
              }
            });
          }
        } //below function is used for sending update progress request for chart

      }, {
        key: "rowClick",
        value: function rowClick(state, row, i) {
          var _this7 = this;

          // let resp = state.data;
          this.chart_query_op = 'UpdateProgress';
          var querycontext = {
            "request_id": this.chart_requestUUID,
            "query_win_size": this.qureyWindowSize,
            "query_start_time": this.gte,
            "query_op": this.chart_query_op,
            "log_level": this.queryLogLevel
          };
          var winNumObj = {
            "sendDoc": true,
            "page_num": 0,
            "page_size": this.pageSize
          };

          if (this.chart_requestUUID != null) {
            this.vis.visualization(this.prevQueryChart, this.indexpattern, this.gte, this.lte, this.sorting, this.metricAggregation, this.chartBucketAggregation, sessionStorage.getItem('_nvtimezone'), this.pipetemindexvalue, this.sourceformatvalue.toString(), 50, this.responseformat, querycontext, winNumObj, this.sortoptionsvalue).subscribe(function (state) {
              var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;

              if (state instanceof _create_visualization_service_visualization_state__WEBPACK_IMPORTED_MODULE_5__["visualLoadedState"]) {
                _this7.exceptionName = row.exceptiontype;
                _this7.logType = row.loglevel;
                _this7.XaxisData = _this7.nf.convertDataIntoTimeZoneData((_a = state === null || state === void 0 ? void 0 : state.data[0]) === null || _a === void 0 ? void 0 : _a.arrTimeStamp);
                _this7.exceptionFirstOccurrence = (_b = state === null || state === void 0 ? void 0 : state.data[0]) === null || _b === void 0 ? void 0 : _b.arrTimeStamp.map(function (time) {
                  return _this7.sessionService.convertTimestampIntoFormattedString(time, 'MM/DD/YYYY HH:mm:ss');
                });
                _this7.exceptionCount = (_d = (_c = state === null || state === void 0 ? void 0 : state.data[0]) === null || _c === void 0 ? void 0 : _c.visualizationData[0]) === null || _d === void 0 ? void 0 : _d.data;
                _this7.exceptionChartLoading = false;

                if (_this7.chartContainer) {
                  _this7.chartContainer.style.display = 'block';
                }

                if ((state === null || state === void 0 ? void 0 : state.data) && ((_e = state === null || state === void 0 ? void 0 : state.data) === null || _e === void 0 ? void 0 : _e.length) > 0) {
                  _this7.logTableData = (_g = (_f = state === null || state === void 0 ? void 0 : state.data[0]) === null || _f === void 0 ? void 0 : _f.logTableData[0]) === null || _g === void 0 ? void 0 : _g.response.filter(function (ele) {
                    return ele.label != '<br>';
                  });

                  _this7.disableCancelButton.emit({
                    cancelIcon: true
                  });
                }

                if (((_j = (_h = state === null || state === void 0 ? void 0 : state.data['0']) === null || _h === void 0 ? void 0 : _h.QueryContext) === null || _j === void 0 ? void 0 : _j.QueryStatus) == 'Processing') {
                  _this7.showExceptionProgressBar.emit({
                    showProgressBar: true
                  });

                  setTimeout(function () {
                    _this7.rowClick(state, row, i);
                  }, _this7.queryProgressUpdateInterval);
                }

                if (((_l = (_k = state === null || state === void 0 ? void 0 : state.data['0']) === null || _k === void 0 ? void 0 : _k.QueryContext) === null || _l === void 0 ? void 0 : _l.QueryStatus) == 'Completed') {
                  //show the progress bar until table request is either completed or cancelled
                  if (_this7.tableRequestStatus == 'Completed' || _this7.tableRequestStatus == 'Cancelled') {
                    _this7.showExceptionProgressBar.emit({
                      showProgressBar: false
                    });
                  }
                }
              }

              return;
            });
          }
        }
      }, {
        key: "ngOnDestroy",
        value: function ngOnDestroy() {
          if (this.requestUUID != null) {
            this.cancelTableQuery(this.requestUUID, this.query, this.bucketAggregation);
          } //cancel the chart request


          if (this.chart_previous_request_id != null) {
            this.cancelTableQuery(this.chart_previous_request_id, this.prevQueryChart, this.chartBucketAggregation);
          }
        }
      }]);
    }();

    LogExceptionsComponent.ctorParameters = function () {
      return [{
        type: src_app_shared_time_bar_service_time_bar_service__WEBPACK_IMPORTED_MODULE_2__["TimebarService"]
      }, {
        type: _create_visualization_service_visualization_service__WEBPACK_IMPORTED_MODULE_3__["VisualizationService"]
      }, {
        type: src_app_core_session_session_service__WEBPACK_IMPORTED_MODULE_4__["SessionService"]
      }, {
        type: _angular_core__WEBPACK_IMPORTED_MODULE_1__["ElementRef"]
      }, {
        type: _service_nf_logs_service__WEBPACK_IMPORTED_MODULE_7__["NfLogsService"]
      }];
    };

    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "sourceformatvalue", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "responseformat", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "sorting", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "switchTab", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "exceptionTableLoading", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "query", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "indexpattern", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "onClickCancel", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "gte", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "lte", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "onClearQueryException", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Input"])()], LogExceptionsComponent.prototype, "querySettingsdata", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Output"])()], LogExceptionsComponent.prototype, "hitsvalue_exception", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Output"])()], LogExceptionsComponent.prototype, "exception_Obj", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Output"])()], LogExceptionsComponent.prototype, "showExceptionProgressBar", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Output"])()], LogExceptionsComponent.prototype, "disableclearsearchbutton", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Output"])()], LogExceptionsComponent.prototype, "cancelExceptionReq", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Output"])()], LogExceptionsComponent.prototype, "disableCancelButton", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Output"])()], LogExceptionsComponent.prototype, "exceptionTableResponse", void 0);
    LogExceptionsComponent = Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Component"])({
      selector: 'app-log-exceptions',
      template: Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__importDefault"])(__webpack_require__(
      /*! raw-loader!./log-exceptions.component.html */
      "./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/log-exceptions/log-exceptions.component.html"))["default"],
      encapsulation: _angular_core__WEBPACK_IMPORTED_MODULE_1__["ViewEncapsulation"].None,
      styles: [Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__importDefault"])(__webpack_require__(
      /*! ./log-exceptions.component.scss */
      "./src/app/pages/home/logstab/log-exceptions/log-exceptions.component.scss"))["default"]]
    })], LogExceptionsComponent);
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/log-exceptions/log-exceptions.module.ts":
  /*!****************************************************************************!*\
    !*** ./src/app/pages/home/logstab/log-exceptions/log-exceptions.module.ts ***!
    \****************************************************************************/

  /*! exports provided: LogExceptionsModule */

  /***/
  function _src_app_pages_home_logstab_logExceptions_logExceptionsModuleTs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "LogExceptionsModule", function () {
      return LogExceptionsModule;
    });
    /* harmony import */


    var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! tslib */
    "./node_modules/tslib/tslib.es6.js");
    /* harmony import */


    var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
    /*! @angular/core */
    "./node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js");
    /* harmony import */


    var _angular_common__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(
    /*! @angular/common */
    "./node_modules/@angular/common/__ivy_ngcc__/fesm2015/common.js");
    /* harmony import */


    var _log_exceptions_component__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(
    /*! ./log-exceptions.component */
    "./src/app/pages/home/logstab/log-exceptions/log-exceptions.component.ts");
    /* harmony import */


    var primeng__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(
    /*! primeng */
    "./node_modules/primeng/__ivy_ngcc__/fesm2015/primeng.js");
    /* harmony import */


    var _angular_forms__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(
    /*! @angular/forms */
    "./node_modules/@angular/forms/__ivy_ngcc__/fesm2015/forms.js");
    /* harmony import */


    var src_app_shared_help_help_module__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(
    /*! src/app/shared/help/help.module */
    "./src/app/shared/help/help.module.ts");
    /* harmony import */


    var highcharts_angular__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(
    /*! highcharts-angular */
    "./node_modules/highcharts-angular/__ivy_ngcc__/fesm2015/highcharts-angular.js");
    /* harmony import */


    var src_app_shared_visualization_visual_chart_visual_chart_module__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(
    /*! src/app/shared/visualization/visual-chart/visual-chart.module */
    "./src/app/shared/visualization/visual-chart/visual-chart.module.ts");

    var imports = [_angular_common__WEBPACK_IMPORTED_MODULE_2__["CommonModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["InputTextModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["ButtonModule"], _angular_forms__WEBPACK_IMPORTED_MODULE_5__["FormsModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["CardModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["DropdownModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["TableModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["CheckboxModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["TooltipModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["SelectButtonModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["InputSwitchModule"], primeng__WEBPACK_IMPORTED_MODULE_4__["TabViewModule"], highcharts_angular__WEBPACK_IMPORTED_MODULE_7__["HighchartsChartModule"], src_app_shared_help_help_module__WEBPACK_IMPORTED_MODULE_6__["HelpModule"], src_app_shared_visualization_visual_chart_visual_chart_module__WEBPACK_IMPORTED_MODULE_8__["VisualChartModule"]];
    var components = [_log_exceptions_component__WEBPACK_IMPORTED_MODULE_3__["LogExceptionsComponent"]];

    var LogExceptionsModule = /*#__PURE__*/_createClass(function LogExceptionsModule() {
      _classCallCheck(this, LogExceptionsModule);
    });

    LogExceptionsModule = Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["NgModule"])({
      declarations: [components],
      imports: [imports],
      exports: [components]
    })], LogExceptionsModule);
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/log-integration/service/log-integration.service.ts":
  /*!***************************************************************************************!*\
    !*** ./src/app/pages/home/logstab/log-integration/service/log-integration.service.ts ***!
    \***************************************************************************************/

  /*! exports provided: Logintegrationservice */

  /***/
  function _src_app_pages_home_logstab_logIntegration_service_logIntegrationServiceTs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "Logintegrationservice", function () {
      return Logintegrationservice;
    });
    /* harmony import */


    var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! tslib */
    "./node_modules/tslib/tslib.es6.js");
    /* harmony import */


    var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
    /*! @angular/core */
    "./node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js");
    /* harmony import */


    var file_saver__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(
    /*! file-saver */
    "./node_modules/file-saver/dist/FileSaver.min.js");
    /* harmony import */


    var file_saver__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(file_saver__WEBPACK_IMPORTED_MODULE_2__);
    /* harmony import */


    var xlsx__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(
    /*! xlsx */
    "./node_modules/xlsx/xlsx.js");
    /* harmony import */


    var xlsx__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(xlsx__WEBPACK_IMPORTED_MODULE_3__);

    var CSV_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8';
    var CSV_EXTENSION = '.csv';

    var Logintegrationservice = /*#__PURE__*/function () {
      function Logintegrationservice() {
        _classCallCheck(this, Logintegrationservice);
      }

      return _createClass(Logintegrationservice, [{
        key: "exportAsCSVFile",
        value: function exportAsCSVFile(json, excelFileName) {
          var worksheet = xlsx__WEBPACK_IMPORTED_MODULE_3__["utils"].json_to_sheet(json);
          var workbook = {
            Sheets: {
              'data': worksheet
            },
            SheetNames: ['data']
          };
          var excelBuffer = xlsx__WEBPACK_IMPORTED_MODULE_3__["write"](workbook, {
            bookType: 'csv',
            type: 'array'
          });
          this.saveAsCSVFile(excelBuffer, excelFileName);
        }
      }, {
        key: "saveAsCSVFile",
        value: function saveAsCSVFile(buffer, fileName) {
          var LogIntegrationData = new Blob([buffer], {
            type: CSV_TYPE
          });
          file_saver__WEBPACK_IMPORTED_MODULE_2__["saveAs"](LogIntegrationData, fileName + CSV_EXTENSION);
        }
      }]);
    }();

    Logintegrationservice = Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Injectable"])({
      providedIn: "root"
    })], Logintegrationservice);
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/log-sequence-diagram/log-sequence-diagram.component.scss":
  /*!*********************************************************************************************!*\
    !*** ./src/app/pages/home/logstab/log-sequence-diagram/log-sequence-diagram.component.scss ***!
    \*********************************************************************************************/

  /*! exports provided: default */

  /***/
  function _src_app_pages_home_logstab_logSequenceDiagram_logSequenceDiagramComponentScss(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony default export */


    __webpack_exports__["default"] = ".signal text {\n  fill: #53B675;\n}\n\n.signal path {\n  fill: #53B675;\n}\n\n.signal text:hover {\n  fill: #5030ef;\n}\n\n.note rect,\n.note path {\n  stroke-width: 0 !important;\n  fill: transparent;\n}\n\n.over {\n  cursor: pointer;\n}\n\n.over rect {\n  stroke-width: 2 !important;\n  fill: var(--background_color_1);\n}\n\n.note text {\n  fill: #2F7045;\n}\n\n.title rect,\n.title path {\n  fill: none;\n}\n\n.actor rect,\n.actor path {\n  fill: #2872C8;\n}\n\n.actor text {\n  fill: #f7f8f9;\n}\n\ndiv.myInvisibleDiv {\n  overflow: hidden;\n  visibility: hidden;\n  height: 0;\n  width: 0;\n}";
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/log-sequence-diagram/log-sequence-diagram.component.ts":
  /*!*******************************************************************************************!*\
    !*** ./src/app/pages/home/logstab/log-sequence-diagram/log-sequence-diagram.component.ts ***!
    \*******************************************************************************************/

  /*! exports provided: LogSequenceDiagramComponent */

  /***/
  function _src_app_pages_home_logstab_logSequenceDiagram_logSequenceDiagramComponentTs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "LogSequenceDiagramComponent", function () {
      return LogSequenceDiagramComponent;
    });
    /* harmony import */


    var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! tslib */
    "./node_modules/tslib/tslib.es6.js");
    /* harmony import */


    var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
    /*! @angular/core */
    "./node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js");
    /* harmony import */


    var _service_nf_logs_service__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(
    /*! ../service/nf-logs.service */
    "./src/app/pages/home/logstab/service/nf-logs.service.ts");
    /* harmony import */


    var src_app_core_session_session_service__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(
    /*! src/app/core/session/session.service */
    "./src/app/core/session/session.service.ts");

    var LogSequenceDiagramComponent = /*#__PURE__*/function () {
      function LogSequenceDiagramComponent(nflogservice, sessionService) {
        _classCallCheck(this, LogSequenceDiagramComponent);

        this.nflogservice = nflogservice;
        this.sessionService = sessionService;
        this.logBlockArray = [];
        this.isSequenceData = true;
      }

      return _createClass(LogSequenceDiagramComponent, [{
        key: "ngAfterViewInit",
        value: function ngAfterViewInit() {
          var _this8 = this;

          console.log(this.nflogservice.sequenceData);
          var logServiceData = this.nflogservice.sequenceData;
          console.log('diagram value is:', Diagram);
          logServiceData.forEach(function (val) {
            _this8.logBlockArray = val.logblock;
            console.log(val.diagramData);
            _this8.diagramValue = val.diagramData;
          });
          this.nflogservice.sequenceData = [];
          var data = this.diagramValue;
          console.log('window is loading', new Diagram());

          if (data.includes("No Data Found")) {
            this.isSequenceData = false;
          } else {
            this.isSequenceData = true;
            var diagram = Diagram.parse(data);
            diagram.drawSVG('diagram', {
              theme: 'simple'
            });
          }

          setTimeout(function () {
            var svg = document.querySelector('svg');
            var svg1 = document.querySelector('path');
            console.log(svg);
            console.log(svg1);
            var a = document.getElementsByClassName("note");
            console.log(a);
            var doc = document.getElementsByTagName('svg');
            console.log(doc);
            var allGTags = document.querySelectorAll('g.note.over'); //getting all g tag 

            console.log(allGTags, 'all g tags');
            allGTags.forEach(function (val, index) {
              // let logBlockData = this.logBlockArray[index].data;
              val.addEventListener('click', function () {
                console.log(index);
                _this8.test = true; // console.log(this.test);

                _this8.openDialog(index);
              });
            });
          }, 5000);
        }
      }, {
        key: "ngOnInit",
        value: function ngOnInit() {
          console.log(this.nflogservice.sequenceData);
        }
      }, {
        key: "openDialog",
        value: function openDialog(index) {
          this.logBlockData = this.logBlockArray[index].data;
          this.startTime = this.sessionService.convertTimestampIntoFormattedString(window.Math.floor(this.logBlockData[0].seqEvent.sourceStartTime / 1000), 'MM/DD/YYYY HH:mm:ss.SSS');
          this.endTime = this.sessionService.convertTimestampIntoFormattedString(window.Math.floor(this.logBlockData[this.logBlockData.length - 1].seqEvent.sourceStartTime / 1000), 'MM/DD/YYYY HH:mm:ss.SSS');
          console.log(this.logBlockData);
        }
      }, {
        key: "getTimeValue",
        value: function getTimeValue(time) {
          return this.sessionService.convertTimestampIntoFormattedString(window.Math.floor(time / 1000), 'MM/DD/YYYY HH:mm:ss.SSS');
        }
      }]);
    }();

    LogSequenceDiagramComponent.ctorParameters = function () {
      return [{
        type: _service_nf_logs_service__WEBPACK_IMPORTED_MODULE_2__["NfLogsService"]
      }, {
        type: src_app_core_session_session_service__WEBPACK_IMPORTED_MODULE_3__["SessionService"]
      }];
    };

    LogSequenceDiagramComponent = Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Component"])({
      selector: 'app-log-sequence-diagram',
      template: Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__importDefault"])(__webpack_require__(
      /*! raw-loader!./log-sequence-diagram.component.html */
      "./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/log-sequence-diagram/log-sequence-diagram.component.html"))["default"],
      encapsulation: _angular_core__WEBPACK_IMPORTED_MODULE_1__["ViewEncapsulation"].None,
      styles: [Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__importDefault"])(__webpack_require__(
      /*! ./log-sequence-diagram.component.scss */
      "./src/app/pages/home/logstab/log-sequence-diagram/log-sequence-diagram.component.scss"))["default"]]
    })], LogSequenceDiagramComponent);
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/logstab.component.scss":
  /*!***********************************************************!*\
    !*** ./src/app/pages/home/logstab/logstab.component.scss ***!
    \***********************************************************/

  /*! exports provided: default */

  /***/
  function _src_app_pages_home_logstab_logstabComponentScss(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony default export */


    __webpack_exports__["default"] = "app-logstab .custom-toast {\n  background-color: var(--danger-400);\n  color: black;\n  width: 250px;\n  position: absolute;\n  top: 40px;\n  right: 16px;\n  z-index: 999999;\n}\napp-logstab .ul-menu {\n  display: none;\n  background: white;\n  position: absolute;\n  border: 1px solid #d8dae2;\n  padding: 0px;\n  z-index: 3;\n  list-style-type: none;\n  box-shadow: 2px 2px 2px #d8dae2;\n  color: black;\n}\napp-logstab .ul-menu li {\n  padding: 5px;\n  width: 100%;\n  border-bottom: 1px solid #d8dae2;\n}\napp-logstab .ul-menu li:last-child {\n  border-bottom: none !important;\n}\napp-logstab .ul-menu li:hover {\n  background-color: #d8dae2;\n}\napp-logstab .bread-crum {\n  color: #1d5290;\n  padding-left: 25px;\n}\napp-logstab .vertical-container .key-label {\n  line-height: 20px;\n}\napp-logstab .vertical-container .icon-button.ui-button.no-shadow .ui-button-text {\n  background: #fff;\n  visibility: visible;\n  border-radius: 4px;\n  padding: 0.31em 1em;\n  border: 1px solid #ccc;\n}\napp-logstab .vertical-container .expand .ui-button-icon :enabled:active {\n  background-color: cadetblue;\n  border-color: crimson;\n}\napp-logstab .vertical-container .icon-button.ui-button.menu-button {\n  margin: 0;\n  float: right;\n  font-size: 1.35em;\n}\napp-logstab .vertical-container .selected-label {\n  line-height: 30px;\n}\napp-logstab .vertical-container .tags-outer .ui-chips-token {\n  max-width: 400px;\n  overflow: hidden;\n  display: inline-block;\n  white-space: nowrap !important;\n  text-overflow: ellipsis;\n}\napp-logstab .vertical-container .tags-outer .ui-chips-token .plusFilter, app-logstab .vertical-container .tags-outer .ui-chips-token .existFilter, app-logstab .vertical-container .tags-outer .ui-chips-token .minusFilter {\n  z-index: 5;\n  position: relative;\n}\napp-logstab .vertical-container .tags-outer .ui-chips-token .plusFilter::after, app-logstab .vertical-container .tags-outer .ui-chips-token .minusFilter::after, app-logstab .vertical-container .tags-outer .ui-chips-token .existFilter::after {\n  position: absolute;\n  left: -10px;\n  right: -43px;\n  bottom: -10px;\n  top: -10px;\n  z-index: -1;\n  content: \"\";\n}\napp-logstab .vertical-container .tags-outer .ui-chips-token .plusFilter::after {\n  background: #469046;\n}\napp-logstab .vertical-container .tags-outer .ui-chips-token .minusFilter::after {\n  background: #EC8282;\n}\napp-logstab .vertical-container .tags-outer .ui-chips-token .existFilter::after {\n  background: #d4a439;\n}\napp-logstab .vertical-container .tags-outer .ui-chips-token .ui-chips-token-icon {\n  z-index: 6;\n}\napp-logstab .vertical-container .tags-outer .ui-chips-token .ui-chips .ui-inputtext {\n  border-top-right-radius: 0px;\n  border-bottom-right-radius: 0px;\n}\napp-logstab .vertical-container .tags-outer .ui-chips ul.ui-inputtext {\n  max-height: 30px;\n}\napp-logstab .vertical-container .ui-inputgroup .ui-button {\n  border-radius: 0px 3px 3px 0px;\n  height: 28px;\n}\napp-logstab .vertical-container .ui-chips > ul.ui-inputtext:not(.ui-state-disabled):hover {\n  border: 1px solid #b0b0b0;\n}\napp-logstab .vertical-container .ui-chips > ul.ui-inputtext .ui-chips-input-token {\n  display: none;\n}\napp-logstab .vertical-container .item-icon {\n  margin: 0 1.2em 0 1em;\n  vertical-align: middle;\n}\napp-logstab .vertical-container .data-collapse {\n  float: right;\n}\napp-logstab .vertical-container .ui-tabmenu .ui-tabmenu-nav {\n  padding: 0;\n}\napp-logstab .vertical-container .ui-tabmenu .ui-tabmenu-nav .ui-tabmenuitem {\n  border-bottom: none;\n}\napp-logstab .vertical-container .tab-content {\n  border: 1px solid #7b7b7b80;\n}\napp-logstab .vertical-container .no-padding {\n  padding: 0.5em 0;\n}\napp-logstab .vertical-container .ui-autocomplete-panel {\n  border: none;\n}\napp-logstab .vertical-container .ui-autocomplete-panel .ui-autocomplete-items .ui-autocomplete-list-item {\n  background-color: #c3d7ea30;\n  color: #333333;\n  border-bottom: 3px solid #ffffff;\n  font-size: 12px;\n  padding: 0.629em 0.857em;\n  transition: background-color 0.2s, box-shadow 0.2s;\n}\napp-logstab .vertical-container .ui-autocomplete-panel .ui-autocomplete-items .ui-autocomplete-list-item:last-child {\n  border: 1px solid #dbdbdb;\n  color: #1d5290;\n  box-shadow: 1px 1px 1px #ccc;\n}\napp-logstab .vertical-container span.badge {\n  font-size: 13px;\n  padding: 0.25em 0.75em;\n  margin: 3px 3px;\n  border-radius: 4px;\n  display: inline-flex;\n}\napp-logstab .vertical-container .bg-green {\n  background-color: #355070;\n  color: #ffffff;\n}\napp-logstab .vertical-container .bg-pink {\n  background-color: #6D597A;\n  color: #ffffff;\n}\napp-logstab .vertical-container .bg-yellow {\n  background-color: #B56576;\n  color: #ffffff;\n}\napp-logstab .vertical-container .bg-voilet {\n  background-color: #E56B6F;\n  color: #ffffff;\n}\napp-logstab .vertical-container .bg-red {\n  background-color: #EAAC8B;\n  color: #ffffff;\n}\napp-logstab .vertical-container .ui-overlaypanel .ui-overlaypanel-content {\n  padding: 1em 2em;\n  box-shadow: 0px 14px 25px #00000033;\n  font-size: 15px;\n}\napp-logstab .vertical-container .row-extra span {\n  font-size: 25px !important;\n  color: #1d5290;\n  cursor: pointer;\n}\napp-logstab .vertical-container .sub-row {\n  cursor: pointer;\n}\napp-logstab .vertical-container .ui-table .ui-table-tbody > tr > td {\n  white-space: break-spaces;\n}\napp-logstab .all-tables .ui-table-thead > tr > th:first-child {\n  width: 90px;\n}\napp-logstab .all-tables .ui-table-tbody > tr > td {\n  vertical-align: top;\n}\napp-logstab app-visual-chart app-chart .chart-container {\n  border: none;\n}\napp-logstab .srcbar {\n  position: relative;\n  z-index: 90;\n}\napp-logstab .srcbar .input-field-search {\n  width: 100%;\n  z-index: 0;\n}\napp-logstab .srcbar .ui-autocomplete .ui-autocomplete-input {\n  padding-left: 6px;\n  z-index: 0;\n  width: 100%;\n  padding-right: 70px;\n}\napp-logstab .srcbar i.filter-icon {\n  font-size: 1.5em;\n  color: #1d5290;\n  margin: 0 10px;\n  background: #fff;\n  border-radius: 4px;\n  padding: 0.21em 0.429em 0.45em 0.429em;\n  border: 1px solid #ccc;\n  cursor: pointer;\n}\napp-logstab .srcbar .search-div-css i.icons8-search {\n  color: #1d5290;\n  z-index: 99;\n}\napp-logstab .srcbar .search-div-css i.icons8-edit-2 {\n  margin: 9px 40px 0 -60px;\n  color: #1d5290;\n  cursor: pointer;\n  position: absolute;\n}\napp-logstab .srcbar .search-div-css .ui-autocomplete {\n  width: 100%;\n}\napp-logstab .srcbar .search-div-css .ui-autocomplete-dropdown {\n  background-color: transparent;\n  color: #ffffff;\n  border: none;\n  border-radius: 5px;\n  position: absolute;\n  right: 5px;\n}\napp-logstab .srcbar .search-div-css .ui-autocomplete-dropdown .ui-button-icon-left {\n  background-color: #1d5290;\n  color: #ffffff;\n  border-radius: 5px;\n  width: 20px;\n}\napp-logstab .srcbar .search-div-css .right10 {\n  position: absolute;\n  right: 10px;\n}\napp-logstab .srcbar .hitsCount {\n  display: flex;\n  flex-wrap: nowrap;\n  white-space: nowrap;\n}\napp-logstab .colWidth12 > col {\n  min-width: 200px !important;\n  width: auto;\n}\napp-logstab .colWidth12 .text-left:first-child {\n  width: 350px !important;\n  min-width: 350px !important;\n  max-width: 350px !important;\n}\napp-logstab .colWidth12 .timeCol {\n  width: 90px !important;\n  min-width: 90px !important;\n  max-width: 120px !important;\n}\napp-logstab .colWidth12 .docClass {\n  width: 70px !important;\n  min-width: 70px !important;\n}\napp-logstab .colWidth12 .elapseClass {\n  width: 75px !important;\n  min-width: 75px !important;\n}\napp-logstab .colWidth12 .ddrIconClass {\n  width: 50px !important;\n  min-width: 50px !important;\n}\napp-logstab .height {\n  max-height: 30px;\n  overflow: hidden;\n  line-height: 14px;\n  -webkit-line-clamp: 21;\n  -webkit-box-orient: vertical;\n  width: 98%;\n}\napp-logstab .height br {\n  display: none;\n}\napp-logstab .ul-docCount {\n  -webkit-text-decoration-line: underline;\n          text-decoration-line: underline;\n  padding: 0px;\n  margin: auto;\n  display: table;\n}\napp-logstab .ul-docCount:hover {\n  color: #9a2f2f;\n}\napp-logstab .dialogBox {\n  max-height: 250px;\n  box-shadow: 5px 5px 5px #57565a;\n}\napp-logstab .dialogBox .ui-dialog-titlebar {\n  background-color: #0f3f77 !important;\n  display: flex;\n  border-top-left-radius: 0px;\n  border-top-right-radius: 0px;\n}\napp-logstab .dialogTable {\n  background-color: #f5f6f7;\n}\napp-logstab .dialogTable tr td {\n  color: #1d5290;\n  font-weight: bold;\n}\napp-logstab .dialogTable tr td:hover {\n  color: darkblue;\n}\napp-logstab .colWidth > col {\n  width: 120px !important;\n  min-width: 120px !important;\n  max-width: 120px !important;\n}\napp-logstab .colWidthSaveQuery > col {\n  width: 100%;\n}\napp-logstab .heightExpand {\n  min-height: 100px;\n}\napp-logstab .heightExpand .parent {\n  display: inline-block;\n}\napp-logstab .collpseIco {\n  position: absolute;\n  top: 0px;\n  right: 0px;\n  z-index: 85;\n}\napp-logstab .thicon {\n  position: absolute;\n  bottom: 5px;\n  right: -4px;\n  z-index: 85;\n}\napp-logstab .columndata {\n  font-size: 11px;\n}\napp-logstab .tabNav .ui-tabmenu-nav {\n  border-bottom: 0px !important;\n}\napp-logstab .logTable .ui-table-thead > tr > th {\n  position: sticky;\n  position: -webkit-sticky;\n  top: 0;\n}\napp-logstab .markClsass {\n  background-color: #ebf43d;\n  color: black;\n  line-break: anywhere;\n}\napp-logstab .markClsassExpand {\n  background-color: #ebf43d;\n  color: black;\n}\napp-logstab .mySlider .sidebar-nav.new-width {\n  min-width: 300px;\n  max-width: 300px;\n}\napp-logstab .mySlider .sidebar-nav.active {\n  margin-left: -300px;\n}\napp-logstab .mySlider .side-bar-content {\n  min-height: calc(100vh - 155px) !important;\n  max-height: calc(100vh - 155px) !important;\n}\napp-logstab .showFilter {\n  width: 190px;\n  border: 1px solid var(--secondary-button-text-color);\n  cursor: pointer;\n  color: var(--secondary-button-text-color);\n  border-radius: 3px;\n}\napp-logstab .histogramClose {\n  position: absolute;\n  z-index: 99;\n  right: 4px;\n  top: 0px;\n}\napp-logstab .autoSuggest .ui-autocomplete-panel .ui-autocomplete-items .ui-autocomplete-list-item {\n  pointer-events: none;\n}\napp-logstab .progress {\n  width: 87.8%;\n  padding-left: 17%;\n  position: relative;\n}\napp-logstab .progressNumber {\n  position: absolute;\n  left: 0px;\n  text-align: right;\n  width: 19%;\n  top: -2px;\n}\napp-logstab .matchingLogItemColWidth > col:last-child {\n  width: 200px !important;\n}\napp-logstab .disableLiEle {\n  pointer-events: none;\n  opacity: 0.6;\n}\napp-logstab .helpIcon {\n  position: relative;\n  top: 3px;\n}\napp-logstab .ui-autocomplete-loader {\n  display: none !important;\n}";
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/logstab.component.ts":
  /*!*********************************************************!*\
    !*** ./src/app/pages/home/logstab/logstab.component.ts ***!
    \*********************************************************/

  /*! exports provided: LogstabComponent */

  /***/
  function _src_app_pages_home_logstab_logstabComponentTs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "LogstabComponent", function () {
      return LogstabComponent;
    });
    /* harmony import */


    var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! tslib */
    "./node_modules/tslib/tslib.es6.js");
    /* harmony import */


    var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
    /*! @angular/core */
    "./node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js");
    /* harmony import */


    var rxjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(
    /*! rxjs */
    "./node_modules/rxjs/_esm2015/index.js");
    /* harmony import */


    var rxjs_operators__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(
    /*! rxjs/operators */
    "./node_modules/rxjs/_esm2015/operators/index.js");
    /* harmony import */


    var primeng__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(
    /*! primeng */
    "./node_modules/primeng/__ivy_ngcc__/fesm2015/primeng.js");
    /* harmony import */


    var src_app_shared_save_dialog_save_dialog_component__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(
    /*! src/app/shared/save-dialog/save-dialog.component */
    "./src/app/shared/save-dialog/save-dialog.component.ts");
    /* harmony import */


    var _service_logstab_dummy__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(
    /*! ./service/logstab.dummy */
    "./src/app/pages/home/logstab/service/logstab.dummy.ts");
    /* harmony import */


    var src_app_shared_time_bar_service_time_bar_service__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(
    /*! src/app/shared/time-bar/service/time-bar.service */
    "./src/app/shared/time-bar/service/time-bar.service.ts");
    /* harmony import */


    var _service_nf_logs_service__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(
    /*! ./service/nf-logs.service */
    "./src/app/pages/home/logstab/service/nf-logs.service.ts");
    /* harmony import */


    var _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(
    /*! ./service/logstab.state */
    "./src/app/pages/home/logstab/service/logstab.state.ts");
    /* harmony import */


    var _query_settings_service_query_settings_service__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(
    /*! ../../query-settings/service/query-settings.service */
    "./src/app/pages/query-settings/service/query-settings.service.ts");
    /* harmony import */


    var _query_settings_service_query_settings_state__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(
    /*! ../../query-settings/service/query-settings.state */
    "./src/app/pages/query-settings/service/query-settings.state.ts");
    /* harmony import */


    var src_app_shared_scheduler_scheduler_service__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(
    /*! src/app/shared/scheduler/scheduler.service */
    "./src/app/shared/scheduler/scheduler.service.ts");
    /* harmony import */


    var lodash__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(
    /*! lodash */
    "./node_modules/lodash/lodash.js");
    /* harmony import */


    var lodash__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(lodash__WEBPACK_IMPORTED_MODULE_13__);
    /* harmony import */


    var _angular_router__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(
    /*! @angular/router */
    "./node_modules/@angular/router/__ivy_ngcc__/fesm2015/router.js");
    /* harmony import */


    var _tools_actions_ddr_data_model_service__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(
    /*! ../../tools/actions/ddr-data-model.service */
    "./src/app/pages/tools/actions/ddr-data-model.service.ts");
    /* harmony import */


    var src_app_core_breadcrumb_breadcrumb_service__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(
    /*! src/app/core/breadcrumb/breadcrumb.service */
    "./src/app/core/breadcrumb/breadcrumb.service.ts");
    /* harmony import */


    var moment_timezone__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(
    /*! moment-timezone */
    "./node_modules/moment-timezone/index.js");
    /* harmony import */


    var moment_timezone__WEBPACK_IMPORTED_MODULE_17___default = /*#__PURE__*/__webpack_require__.n(moment_timezone__WEBPACK_IMPORTED_MODULE_17__);
    /* harmony import */


    var src_app_core_session_session_service__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(
    /*! src/app/core/session/session.service */
    "./src/app/core/session/session.service.ts");
    /* harmony import */


    var _log_integration_service_log_integration_service__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(
    /*! ./log-integration/service/log-integration.service */
    "./src/app/pages/home/logstab/log-integration/service/log-integration.service.ts");
    /* harmony import */


    var _service_config_service__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(
    /*! ./service/config.service */
    "./src/app/pages/home/logstab/service/config.service.ts");
    /* harmony import */


    var _my_library_search_service_search_service__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(
    /*! ../../my-library/search/service/search.service */
    "./src/app/pages/my-library/search/service/search.service.ts");
    /* harmony import */


    var _my_library_search_service_search_state__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(
    /*! ../../my-library/search/service/search.state */
    "./src/app/pages/my-library/search/service/search.state.ts");
    /* harmony import */


    var _monitor_up_down_status_configure_monitors_add_custom_monitor_services_custom_monitor_service__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(
    /*! ../../monitor-up-down-status/configure-monitors/add-custom-monitor/services/custom-monitor.service */
    "./src/app/pages/monitor-up-down-status/configure-monitors/add-custom-monitor/services/custom-monitor.service.ts");
    /* harmony import */


    var _monitor_up_down_status_service_utility_service__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(
    /*! ../../monitor-up-down-status/service/utility.service */
    "./src/app/pages/monitor-up-down-status/service/utility.service.ts");
    /* harmony import */


    var _monitor_up_down_status_service_monitorupdownstatus_service__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(
    /*! ../../monitor-up-down-status/service/monitorupdownstatus.service */
    "./src/app/pages/monitor-up-down-status/service/monitorupdownstatus.service.ts");
    /* harmony import */


    var _antlr_index_js__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(
    /*! ./antlr/index.js */
    "./src/app/pages/home/logstab/antlr/index.js");
    /* harmony import */


    var _nf_add_remote_cluster_nf_remote_cluster_service_nf_remote_cluster_service__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(
    /*! ../../nf-add-remote-cluster/nf-remote-cluster-service/nf-remote-cluster.service */
    "./src/app/pages/nf-add-remote-cluster/nf-remote-cluster-service/nf-remote-cluster.service.ts");
    /* harmony import */


    var _nf_add_remote_cluster_nf_remote_cluster_service_nf_remote_cluster_state__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(
    /*! ../../nf-add-remote-cluster/nf-remote-cluster-service/nf-remote-cluster.state */
    "./src/app/pages/nf-add-remote-cluster/nf-remote-cluster-service/nf-remote-cluster.state.ts");
    /* harmony import */


    var src_app_shared_time_bar_service_time_bar_state__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(
    /*! src/app/shared/time-bar/service/time-bar.state */
    "./src/app/shared/time-bar/service/time-bar.state.ts");
    /* harmony import */


    var src_app_shared_cav_toast_service_cav_message_service__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(
    /*! src/app/shared/cav-toast/service/cav-message.service */
    "./src/app/shared/cav-toast/service/cav-message.service.ts");
    /* harmony import */


    var uuid__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(
    /*! uuid */
    "./node_modules/uuid/dist/esm-browser/index.js");
    /* harmony import */


    var src_app_shared_pipes_pipe_service__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(
    /*! src/app/shared/pipes/pipe.service */
    "./src/app/shared/pipes/pipe.service.ts");
    /* harmony import */


    var src_app_pages_tools_admin_access_control_services_access_control_model__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(
    /*! src/app/pages/tools/admin/access-control/services/access-control.model */
    "./src/app/pages/tools/admin/access-control/services/access-control.model.ts");
    /* harmony import */


    var _tools_admin_access_control_management_constants_cav_acl_features_constants__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(
    /*! ../../tools/admin/access-control-management/constants/cav-acl-features.constants */
    "./src/app/pages/tools/admin/access-control-management/constants/cav-acl-features.constants.ts");

    var LogstabComponent = /*#__PURE__*/function () {
      function LogstabComponent(cd, _ddrData, breadcrumb, route, schedulerService, messageService, nf, router, tb, qs, sessionService, logIntegrationService, configService, savedSerchService, customMonitorService, monUpDownStatus, remoteCluster, confirmationService, renderer, pipeService, aclProperties) {
        var _this9 = this;

        _classCallCheck(this, LogstabComponent);

        this.cd = cd;
        this._ddrData = _ddrData;
        this.breadcrumb = breadcrumb;
        this.route = route;
        this.schedulerService = schedulerService;
        this.messageService = messageService;
        this.nf = nf;
        this.router = router;
        this.tb = tb;
        this.qs = qs;
        this.sessionService = sessionService;
        this.logIntegrationService = logIntegrationService;
        this.configService = configService;
        this.savedSerchService = savedSerchService;
        this.customMonitorService = customMonitorService;
        this.monUpDownStatus = monUpDownStatus;
        this.remoteCluster = remoteCluster;
        this.confirmationService = confirmationService;
        this.renderer = renderer;
        this.pipeService = pipeService;
        this.aclProperties = aclProperties;
        this.menu_bar = '';
        this.chipsValues = [];
        this.checkTab = 0;
        this.checked = true;
        this.selectedText = '';
        this.hitsValue = 0;
        this.isFromDDR = false;
        this.isTimeChangeByTB = false;
        this.searchVal = false;
        this.clearVal = false;
        this.isCustomTable = false;
        this.isCreateTable = false;
        this.sorting = 'desc';
        this.sorting_input = true;
        this.rowClick = new _angular_core__WEBPACK_IMPORTED_MODULE_1__["EventEmitter"]();
        this.showExpandedDiv = false;
        this.fieldExpandedDiv = true;
        this.chartXaxisData = [];
        this.chartYaxisData = [];
        this.query = '';
        this.tabledata = [];
        this.Error = '';
        this.tracktotalhitsvalue = 10000;
        this.isLargeDataSet = true;
        this.stats = [];
        this.exist_arr = [];
        this.minus_arr = [];
        this.plus_arr = [];
        this.kpiURL = '/kpi';
        this.endToEndURL = '/end-to-end';
        this.geoLocationURL = '/geo-location';
        this.initialdata = false;
        this.selectRow = {};
        this.showSimilarDataFollowLogStream = true;
        this.showCacheButton = false;
        this.update_gte_lte_with_logstream = false;
        this.isInstanceFollowLogStream = false;
        this.isCacheButton = false;
        this.first = 0;
        this.showSavedSearchDialog = false;
        this.saveSearchedData = [];
        this.isFromSaveQuery = false;
        this.isWhereLog_key = false;
        this.sortValue = '';
        this.isDedupChecked = true;
        this.zoomCheck = false;
        this.isZoom = true;
        this.similerMessage = null;
        this.similerLogHiglight = false;
        this.similerMessageVal = null;
        this.similerLogHiglightVal = false;
        this.isSorting = true;
        this.toggleColSelectedOption = false;
        this.isFilterBarShowing = false;
        this.messageLength = 2;
        this.histogramTable = true;
        this.isRequest = false;
        this.isResponse = false;
        this.isStatistic = false;
        this.isActionOption = false;
        this.isHistogramToggle = false;
        this.expandedRowData = '';
        this.expandedRowNum = 0;
        this.isInitial = true;
        this.toggleColumnOption = [];
        this.isMenu = true;
        this.tableHeight = 509;
        this.expandedRows = {};
        this.showingNoResult = false;
        this.isDisableAll = false;
        this.visualTableHeight = 405;
        this.isGroupSimilar = false;
        this.logStreamVal = '';
        this.searchbarVisibleQuery = '';
        this.cacheSearchBarVisibleQuery = '';
        this.ddrQueryValue = '';
        this.showSequence = false;
        this.indexRef = _antlr_index_js__WEBPACK_IMPORTED_MODULE_26__;
        this.autoSuggestions = [];
        this.prevSuggestedQuery = '';
        this.isFieldValue = false;
        this.selectedSuggestionval = '';
        this.clusterName = [];
        this.remotedata = {};
        this.clusterIndex = '*';
        this.isApplyTimeFilter = false;
        this.destroy = new rxjs__WEBPACK_IMPORTED_MODULE_2__["Subject"]();
        this.isSuggSelected = false;
        this.noAvailData = false;
        this.isTableExpand = false;
        this.isMenuVisible = false;
        this.getTimeValuesBeforeZoom = [];
        this.previousQuery = '';
        this.previousIndex = '';
        this.prevMinusFilter = '';
        this.prevPlusFilster = '';
        this.prevExistFilter = '';
        this.prevSortValue = '';
        this.prevGteValue = 0;
        this.prevLteValue = 0;
        this.showProgressBar = false;
        this.value = 0;
        this.displayProcessDoc = false;
        this.matchedCount = 0;
        this.processedCount = 0;
        this.totalCount = 0;
        this.initialLoadValue = true;
        this.regex = '';
        this.showRegex = false;
        this.savedExtractFields = [];
        this.savedExtractFieldsItem = [];
        this.isFieldNameEnable = false;
        this.selectedTextLog = '';
        this.similarSourceTypeMsg = [];
        this.showMatchingLogs = false;
        this.similarSourceTypeMsgMatchVal = [];
        this.showSavedExtractedField = false;
        this.isEditExistExtractedField = false;
        this.showClock = false;
        this.showSelectedLogMsg = true;
        this.similarSourceTypeMsgMatchIdx = [];
        this.isRequestCancelled = true;
        this.showFullError = '';
        this.isShowMoreBtn = false;
        this.isCustomError = false;
        this.timerId = '';
        this.indexpattern = "*";
        this.switchTab = null;
        this.exceptionTableLoading = false;
        this.lastGraphUpdateTime = null;
        this.onClickCancel = false;
        this.savedExtractFieldsList = [];
        this.logSource = 'nfdb_cluster';
        this.saveLogQueryHeaderrealtivePath = "netforest/save-log-query-table.json";
        this.saveExtractFieldsHeaderRelativePath = "netforest/save-extract-fields-table.json";
        this.onClearQueryException = false;
        this.isCancelButtonDisable = true;
        this.leftSqrBracePresent = false;
        this.isBackspaceBtnPressed = false;
        this.logsCountLoading = true;
        this.isPermissionForQuery = false;
        this.remove_event = this.renderer.listen('window', 'click', function (e) {
          var text = document.getSelection().toString();

          if (_this9.menu_bar != '' && _this9.isMenuVisible == true && text === '') {
            _this9.menu_bar.hide();

            _this9.isMenuVisible = false;
          }
        });
        this.getSavedExtractedFields();
      }

      return _createClass(LogstabComponent, [{
        key: "beforeUnloadHandler",
        value: function beforeUnloadHandler(event) {
          if (window['logLevel'] > 0) {
            console.log('calling window before unload');
          }

          event.returnValue = false;
          this.ngOnDestroy();
        }
      }, {
        key: "exportAsCSV",
        value: function exportAsCSV() {
          var _ref,
              _this0 = this;

          var exportData = [];

          var _iterator9 = _createForOfIteratorHelper(this.data.data.tableData),
              _step9;

          try {
            var _loop = function _loop() {
              var obj = _step9.value;

              var sortTime = _this0.sessionService.convertTimestampIntoFormattedString(obj.Time, 'YYYY-MM-DD hh:mm:ss');

              obj['Time'] = sortTime;
              var expObj = {};
              if (obj['no']) expObj['S.No'] = obj['no'];
              if (obj['Time']) expObj['Time'] = obj['Time'];

              if (obj['response'] != undefined && obj['response'].length > 0) {
                var temp = JSON.parse(JSON.stringify(obj['response']));
                temp.forEach(function (val, index) {
                  if (val.label != '<br>') {
                    if (val.value != undefined && typeof val.value == 'string') {
                      val.value = val.value.replace(/<mark>/g, '');
                      val.value = val.value.replace(/<\/mark>/g, '');
                    }

                    expObj[val.label] = val.value;
                  }
                });
              }

              exportData.push(expObj);
            };

            for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
              _loop();
            }
          } catch (err) {
            _iterator9.e(err);
          } finally {
            _iterator9.f();
          }

          var keyExportObj = (_ref = []).concat.apply(_ref, _toConsumableArray(exportData.map(Object.keys)));

          function removeDuplicates(keyExportObj) {
            return keyExportObj.filter(function (item, index) {
              return keyExportObj.indexOf(item) === index;
            });
          }

          this.keyExportData = removeDuplicates(keyExportObj);
          var exportExcelData = new Array();
          exportData.forEach(function (row) {
            var rowValue = [];

            _this0.keyExportData.forEach(function (key, ind) {
              if (row[key]) {
                rowValue.push(row[key]);
              } else {
                rowValue.push('-');
              }
            });

            exportExcelData.push(rowValue);
          });
          var reportData = {
            title: 'LOG DATA',
            data: exportExcelData,
            headers: this.keyExportData,
            gteTime: this.gte,
            lteTime: this.lte
          };
          this.nf.exportExcel(reportData);
        }
      }, {
        key: "ngOnInit",
        value: function ngOnInit() {
          var _this1 = this;

          this.getRemoteClusterName();
          this.interval = this.tb.getValue().viewBy.selected.id + 's';
          this.gte = this.sessionService.convertTimestampIntoFormattedString(this.tb.getValue().time.frameStart.value, 'MM/DD/YYYY HH:mm:ss');
          this.lte = this.sessionService.convertTimestampIntoFormattedString(this.tb.getValue().time.frameEnd.value, 'MM/DD/YYYY HH:mm:ss');
          this.nf.timeDataCarrier.pipe(Object(rxjs_operators__WEBPACK_IMPORTED_MODULE_3__["takeUntil"])(this.destroy)).subscribe(function (data) {
            if (data['time'] == true) {
              _this1.searchVal = true;
              _this1.isTimeChangeByTB = true;
              _this1.gte = undefined;
              _this1.lte = undefined;
              _this1.interval = data['view'] + 's';

              _this1.fetchData();
            }
          });
          this.nf.prevSegmentVal.pipe(Object(rxjs_operators__WEBPACK_IMPORTED_MODULE_3__["takeUntil"])(this.destroy)).subscribe(function (data) {
            _this1.gte = undefined;
            _this1.lte = undefined;
            setTimeout(function () {
              _this1.fetchData();
            }, 500);
          });
          this.nf.nextSegmentVal.pipe(Object(rxjs_operators__WEBPACK_IMPORTED_MODULE_3__["takeUntil"])(this.destroy)).subscribe(function (data) {
            _this1.gte = undefined;
            _this1.lte = undefined;
            setTimeout(function () {
              _this1.fetchData();
            }, 500);
          });
          this.nf.timeSliderVal.pipe(Object(rxjs_operators__WEBPACK_IMPORTED_MODULE_3__["takeUntil"])(this.destroy)).subscribe(function (data) {
            _this1.gte = undefined;
            _this1.lte = undefined;
            setTimeout(function () {
              _this1.fetchData();
            }, 500);
          }); //disable Auto Refresh

          this.tb.disableAutoRefresh(this.aclProperties.feature);

          if (window['logLevel'] > 0) {
            console.log(this.interval);
          }

          this.schedulerService.unsubscribe('global-timebar');
          this.isPermissionForQuery = this.sessionService.isFeatureWrite(_tools_admin_access_control_management_constants_cav_acl_features_constants__WEBPACK_IMPORTED_MODULE_34__["CAV_FEATURES"].LOGS.NAME, _tools_admin_access_control_management_constants_cav_acl_features_constants__WEBPACK_IMPORTED_MODULE_34__["CAV_FEATURES"].LOGS.SUB_FEATURES.QUERY);
          this.userPermission = this.isPermissionForQuery ? true : false;

          if (window['logLevel'] > 0) {
            console.log('User permission is ::', this.userPermission);
            console.log(this.tb.getValue());
          }

          var me = this;
          this.searchVal = true;
          me.clearVal = true;
          me.loading = true;
          me.settingOptions = [{
            label: 'Alerts'
          }, {
            label: 'Dashboard'
          }, {
            label: 'Tier Status'
          }];
          me.ddrItems = [{
            label: 'Show All Logs by fpi'
          }, {
            label: 'Open Transaction By fpi'
          }, {
            label: 'Open Timing by fpi'
          }, {
            label: 'Open Replay by fpi'
          }];
          me.actionOptions = [{
            label: 'Export'
          }];
          me.toggleColumnOption = [{
            label: 'Diff(ms)',
            toggleColSelectedOption: false
          }, {
            label: 'Elapsed',
            toggleColSelectedOption: false
          }];
          me.showItems = [{
            label: 'Show Request'
          }, {
            label: 'Show Response'
          }, {
            label: 'Show Statistic'
          }, {
            label: 'Show Extracted Fields'
          }];
          me.matchingLogItem = [{
            label: 'Message'
          }, {
            label: ''
          }];
          this.extractFields = {
            selectedText: '',
            selectedTextType: '',
            rex: '',
            title: '',
            type: 'logExtract',
            selectedTextMsg: '',
            startIdx: 1
          };
          me.widgetReportItems = [{
            label: 'HISTOGRAM',
            command: function command(event) {
              me.checkTab = 0;
            }
          }, {
            label: 'TABLE',
            command: function command(event) {
              me.checkTab = 1;
            }
          }];
          me.data = JSON.parse(JSON.stringify(_service_logstab_dummy__WEBPACK_IMPORTED_MODULE_6__["LOGS_DATA"]));
          me.menuOptions = [{
            label: 'Disable All',
            command: function command(event) {
              me.chipsValues = [];
              me.plus_arr = [];
              me.minus_arr = [];
              me.exist_arr = [];

              _this1.fetchData();

              _this1.isDisableAll = true;
            }
          }];
          this.qs.initialsettings().subscribe(function (state) {
            if (state instanceof _query_settings_service_query_settings_state__WEBPACK_IMPORTED_MODULE_11__["QuerySettingsLoadingState"]) {
              _this1.onqueryDataLoading(state);

              return;
            }

            if (state instanceof _query_settings_service_query_settings_state__WEBPACK_IMPORTED_MODULE_11__["QuerySettingsLoadedState"]) {
              _this1.onqueryDataLoaded(state);

              return;
            }
          }, function (state) {
            _this1.onqueryDataLoadingError(state);
          });
        }
      }, {
        key: "clickButtonEvent",
        value: function clickButtonEvent(event) {
          var _a, _b;

          var me = this;

          if (((_b = (_a = event === null || event === void 0 ? void 0 : event.cavEventExt) === null || _a === void 0 ? void 0 : _a.actionConfig) === null || _b === void 0 ? void 0 : _b.action) == "clickable") {
            me.openSearchData(event.cavEventExt.row);
          }
        }
      }, {
        key: "autoRefresh",
        value: function autoRefresh() {
          var _this10 = this;

          //auto selected-> refresh in every 10sec
          var timer = this.tb.getValue().viewBy.selected.label == 'Auto' ? 10 * 1000 : Number(this.tb.getValue().viewBy.selected.id) * 1000;

          if (window['logLevel'] > 0) {
            console.log("timer::::::::::::", timer);
          }

          if (this.isPauseBtn != true) {
            //auto refresh enable
            this.gte = undefined;
            this.lte = undefined;
            this.fetchData();
            setTimeout(function () {
              _this10.autoRefresh();
            }, timer);
          } else {
            //stop auto refresh
            clearTimeout(timer);
            timer = 0;
          }
        }
      }, {
        key: "ngOnDestroy",
        value: function ngOnDestroy() {
          if (this.requestUUID != null) {
            this.cancelPreviousQuery();
          }

          this.destroy.next(true);
          this.destroy.unsubscribe();
          this.remove_event();
          this.tb.enableAutoRefresh(this.aclProperties.feature);
        }
      }, {
        key: "existingColumnsInLogtable",
        value: function existingColumnsInLogtable() {
          var isIconColumn = false;
          var isDiffColumn = false;
          var isElapsedColumn = false;
          var isTimeColumn = false;
          this.data.headers[0].cols.forEach(function (ele) {
            if (ele.label == 'Diff(ms)') {
              isDiffColumn = true;
            }

            if (ele.label == 'Elapsed(ms)') {
              isElapsedColumn = true;
            }

            if (ele.label == 'Time') {
              isTimeColumn = true;
            }

            if (ele.label == '') {
              isIconColumn = true;
            }
          });
          var isCountColumn = this.query.includes('|dedup log_key') ? true : false;
          return {
            isIconColumn: isIconColumn,
            isDiffColumn: isDiffColumn,
            isElapsedColumn: isElapsedColumn,
            isTimeColumn: isTimeColumn,
            isCountColumn: isCountColumn
          };
        }
      }, {
        key: "getColumnObject",
        value: function getColumnObject(label, valueField, className) {
          var item = {
            label: label,
            valueField: valueField,
            classes: className,
            width: '15%'
          };
          return item;
        }
      }, {
        key: "selectItems",
        value: function selectItems($event, column) {
          column.toggleColSelectedOption = $event.checked;
          var res = this.existingColumnsInLogtable();

          if (column.label == 'Diff(ms)' && column.toggleColSelectedOption == true && res.isDiffColumn == false) {
            var obj = this.getColumnObject('Diff(ms)', 'Time Diff', 'docClass');
            res.isTimeColumn == true ? this.data.headers[0].cols.splice(1, 0, obj) : this.data.headers[0].cols.splice(0, 0, obj);
          }

          if (column.label == 'Diff(ms)' && column.toggleColSelectedOption == false && res.isDiffColumn == true) {
            res.isTimeColumn == true ? this.data.headers[0].cols.splice(1, 1) : this.data.headers[0].cols.splice(0, 1);
          }

          if (column.label == 'Elapsed' && column.toggleColSelectedOption == true && res.isElapsedColumn == false && res.isDiffColumn == false) {
            var _obj = this.getColumnObject('Elapsed(ms)', 'Elapsed Time', 'elapseClass');

            res.isTimeColumn == true ? this.data.headers[0].cols.splice(1, 0, _obj) : this.data.headers[0].cols.splice(0, 0, _obj);
          }

          if (column.label == 'Elapsed' && column.toggleColSelectedOption == true && res.isElapsedColumn == false && res.isDiffColumn == true) {
            var _obj2 = this.getColumnObject('Elapsed(ms)', 'Elapsed Time', 'elapseClass');

            res.isTimeColumn == true ? this.data.headers[0].cols.splice(2, 0, _obj2) : this.data.headers[0].cols.splice(1, 0, _obj2);
          }

          if (column.label == 'Elapsed' && column.toggleColSelectedOption == false && res.isElapsedColumn == true && res.isDiffColumn == false) {
            res.isTimeColumn == true ? this.data.headers[0].cols.splice(1, 1) : this.data.headers[0].cols.splice(0, 1);
          }

          if (column.label == 'Elapsed' && column.toggleColSelectedOption == false && res.isElapsedColumn == true && res.isDiffColumn == true) {
            res.isTimeColumn == true ? this.data.headers[0].cols.splice(2, 1) : this.data.headers[0].cols.splice(1, 1);
          }

          this.data.headers[0].cols = JSON.parse(JSON.stringify(this.data.headers[0].cols));
        }
      }, {
        key: "onqueryDataLoading",
        value: function onqueryDataLoading(state) {
          var me = this;
          me.querySettingsdata = null;
          me.error = null;
        }
      }, {
        key: "toggle",
        value: function toggle() {
          var _this11 = this;

          this.fieldExpandedDiv = !this.fieldExpandedDiv; //refresh/reload the chart if chart is visible while toggling

          if (this.showExpandedDiv) {
            this.showExpandedDiv = !this.showExpandedDiv;
            setTimeout(function () {
              _this11.showExpandedDiv = !_this11.showExpandedDiv;
            }, 100);
          }
        }
      }, {
        key: "togleTable",
        value: function togleTable(rowIndex) {
          this['isTableExpand' + rowIndex] = !this['isTableExpand' + rowIndex];
        }
      }, {
        key: "moreinfo",
        value: function moreinfo(e, rowData, rowIndex) {
          this.selectRow[rowData.no] = this.selectRow[rowData.no] == undefined || this.selectRow[rowData.no] == 0 ? 1 : 0;

          if (window['logLevel'] > 0) {
            console.log(this.selectRow[rowData.no]);
          }

          if (this.menu_bar != '') {
            this.menu_bar.hide();
          }

          if (this.selectRow[rowData.no] == 0) {
            this.expandedRows = {};
          }

          this['isTableExpand' + rowIndex] = false;
        }
      }, {
        key: "onqueryDataLoadingError",
        value: function onqueryDataLoadingError(state) {
          var me = this;
          me.querySettingsdata = null;
          me.Error = state.error['error'];
          this.searchVal = false;
          this.clearVal = false;
          this.loading = false;
          this.logsCountLoading = false;
          me.showingNoResult = true;
          me.isMenu = false;
          me.messageService.add({
            severity: 'error',
            summary: 'Node Error:-',
            detail: me.Error,
            sticky: false,
            life: 10000
          });
        }
      }, {
        key: "cancelPreviousQuery",
        value: function cancelPreviousQuery() {
          if (this.switchTab == 'logs' || this.switchTab == null) {
            var queryContext = {
              "request_id": this.requestUUID,
              "query_win_size": this.qureyWindowSize,
              "query_start_time": moment_timezone__WEBPACK_IMPORTED_MODULE_17__().valueOf(),
              "query_op": "Cancel",
              "log_level": this.queryLogLevel
            };
            var winNumObj = {
              "sendDoc": "false",
              "page_num": 0,
              "page_size": this.pageSize
            };
            this.cancelQueryRequest(this.previousIndex, this.previousQuery, this.tb.getValue().time.frameStart.value, this.tb.getValue().time.frameEnd.value, this.sorting, 50, this.pipetemindexvalue, this.tracktotalhitsvalue, this.sourceformatvalue.join(','), this.plus_arr, this.minus_arr, this.exist_arr, this.maxDocs, this.isLargeDataSet, this.responseformat, this.interval, sessionStorage.getItem('_nvtimezone'), this.sortoptionsvalue, queryContext, winNumObj);
          } else {
            this.onClickCancel = true;
          }
        }
      }, {
        key: "convertGteLteInToTimestamp",
        value: function convertGteLteInToTimestamp(gte, lte) {
          if (gte.includes('/') && lte.includes('/')) {
            gte = this.sessionService.convertFormattedStringIntoTimestamp(gte, 'MM/DD/YYYY HH:mm:ss');
            lte = this.sessionService.convertFormattedStringIntoTimestamp(lte, 'MM/DD/YYYY HH:mm:ss');
          }

          return {
            gte: gte,
            lte: lte
          };
        }
      }, {
        key: "getProcessedRecords",
        value: function getProcessedRecords(sendDoc) {
          var _this12 = this;

          var query_op = 'UpdateProgress';
          var queryContext = {
            "request_id": this.requestUUID,
            "query_win_size": this.qureyWindowSize,
            "query_start_time": moment_timezone__WEBPACK_IMPORTED_MODULE_17__().valueOf(),
            "query_op": query_op,
            "log_level": this.queryLogLevel
          };
          var winNumObj = {
            "sendDoc": sendDoc,
            "page_num": 0,
            "page_size": this.pageSize
          };

          if (this.isRequestCancelled == false) {
            this.nf.clientMsearch(this.previousIndex, this.previousQuery, this.tb.getValue().time.frameStart.value, this.tb.getValue().time.frameEnd.value, this.sorting, 50, this.pipetemindexvalue, this.tracktotalhitsvalue, this.sourceformatvalue.join(','), this.plus_arr, this.minus_arr, this.exist_arr, this.maxDocs, this.isLargeDataSet, this.responseformat, this.interval, sessionStorage.getItem('_nvtimezone'), this.sortoptionsvalue, this.clusterName, this.savedExtractFields, queryContext, winNumObj, this.logSource).subscribe(function (state) {
              if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["LogsLoadingState"]) {
                return;
              }

              if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["LogsLoadedState"]) {
                if (state.data != undefined && state.data['streamStatistics'] != undefined) {
                  _this12.matchedCount = state.data['streamStatistics'].matchedCount;
                  _this12.processedCount = state.data['streamStatistics'].processedCount;
                  _this12.totalCount = state.data['streamStatistics'].totalCount;

                  if (state.data['QueryContext'].QueryStatus == 'Processing' && _this12.matchedCount > 0) {
                    _this12.hitsValue = _this12.matchedCount;
                    _this12.logsCountLoading = false;
                  }

                  _this12.searchVal = true;
                }

                if (sendDoc == 'true') {
                  if (_this12.initialLoadValue == true) {
                    _this12.oninitialLoaded(state);
                  } else {
                    _this12.onLoaded(state);
                  }
                } else if (sendDoc == 'false') {
                  _this12.isMenu = false;
                  _this12.clearVal = false;
                  _this12.loading = false;
                  _this12.isSorting = true; //  below lines are using for passing graphinterval in histogram

                  var currenttime = moment_timezone__WEBPACK_IMPORTED_MODULE_17__().valueOf();

                  if (currenttime - _this12.lastGraphUpdateTime >= _this12.graphUpdateInterval) {
                    _this12.onaggLoaded(state);
                  }
                }

                if (state.data['QueryContext'].QueryStatus == 'Processing') {
                  _this12.clearGetDataRequest = setTimeout(function () {
                    _this12.getProcessedRecords(_this12.data.data.tableData.length > 0 ? "false" : "true");
                  }, _this12.queryProgressUpdateInterval);
                }

                if (state.data['QueryContext'].QueryStatus == 'Completed') {
                  _this12.displayProcessDoc = false;
                  _this12.logsCountLoading = false;
                  _this12.showProgressBar = false;
                  _this12.searchVal = false;
                  _this12.hitsValue = _this12.matchedCount;

                  if (_this12.hitsValue == 0) {
                    _this12.showingNoResult = true;
                  } else {
                    _this12.showingNoResult = false;
                  }
                }

                return;
              }
            }, function (state) {
              _this12.logsCountLoading = false;

              _this12.onLoadingError(state);
            });
          }
        }
      }, {
        key: "onqueryDataLoaded",
        value: function onqueryDataLoaded(state) {
          var _this13 = this;

          var me = this;
          me.querySettingsdata = state.data;

          if (window['logLevel'] > 0) {
            console.log(me.querySettingsdata);
          }

          this.setQuerySettingData(me.querySettingsdata);
          this.route.queryParams.subscribe(function (data) {
            if (window['logLevel'] > 0) {
              console.log(data);
            }

            if (data.query) {
              _this13.isFromSaveQuery = true;
              _this13.query = data.query;

              if (_this13.query.includes('|dedup log_key')) {
                _this13.isDedupChecked = true;
              } else {
                _this13.isDedupChecked = false;
              } //changes regarding Bug 146003


              if (data.query == 'index=* query=*|dedup log_key' || data.query == 'index=* query=*') {
                document.getElementById('searchQuery')['value'] = '';
              } else {
                document.getElementById('searchQuery')['value'] = _this13.isDedupChecked == true && data.query.startsWith("index=") == false ? data.query.substring(0, data.query.indexOf('|dedup log_key')) : data.query;
              }

              _this13.gte = data.gte;
              _this13.lte = data.lte;
              _this13.title = data.title;
              _this13.saveSearchData.saveTitle = _this13.title;

              _this13.breadcrumb.removeAll();

              _this13.initialdata = true;

              _this13.fetchData();
            } else if (data.queryStr && _this13.isTimeChangeByTB == false) {
              if (_this13._ddrData.isFromFlowpath) {
                _this13.breadcrumb.add({
                  label: 'Flowpath',
                  routerLink: '/ddr/flowpath'
                });

                _this13.breadcrumb.add({
                  label: 'Logs',
                  routerLink: '/home/logs',
                  queryParams: data
                });

                _this13._ddrData.isFromFlowpath = false;
              } else {
                _this13.breadcrumb.add({
                  label: 'Logs',
                  routerLink: '/home/logs',
                  queryParams: data
                });
              }

              if (!data.fromFav) {
                _this13.isFromDDR = true;
                _this13.query = 'index=* query=' + data.queryStr;
                _this13.ddrQueryValue = data.queryStr;
              } else {
                _this13.isFromDDR = false;
                _this13.query = 'index=' + data.indexPattern + ' query=' + data.queryStr;
              }

              var str1 = _this13.query.substring(_this13.query.indexOf('query=') + 6, _this13.query.indexOf('|dedup log_key'));

              var str2 = _this13.query.substring(_this13.query.indexOf('query=') + 6);

              _this13.displaySearchbarQuery(str1, str2);

              _this13.gte = data.startTime;
              _this13.lte = data.endTime;
              _this13.initialdata = true;

              _this13.fetchData();
            } else {
              _this13.breadcrumb.removeAll();
            }

            _this13.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];
          });
          this.tb.instance.getInstance().subscribe(function () {
            var value = me.tb.getValue();
            var timePeriod = lodash__WEBPACK_IMPORTED_MODULE_13__["get"](value, 'timePeriod.selected.id', null);
            var viewBy = lodash__WEBPACK_IMPORTED_MODULE_13__["get"](value, 'viewBy.selected.id', null);
            var st = lodash__WEBPACK_IMPORTED_MODULE_13__["get"](value, 'time.frameStart.value', null);
            var et = lodash__WEBPACK_IMPORTED_MODULE_13__["get"](value, 'time.frameEnd.value', null);

            if (window['logLevel'] > 0) {
              console.log(viewBy);
            }

            if (timePeriod) {
              me.kpiURL += '/graphical';
              me.endToEndURL += '/graphical-tier/' + timePeriod + '/' + viewBy;
              me.geoLocationURL += '/details/' + timePeriod + '/' + st + '/' + et;
            }

            var timebarValueInput = {
              timePeriod: value.timePeriod.selected.id,
              viewBy: value.viewBy.selected.id,
              running: value.running,
              discontinued: value.discontinued
            };

            if (window['logLevel'] > 0) {
              console.log(timebarValueInput);
            }

            me.tb.prepareValue(timebarValueInput, me.tb.getValue()).subscribe(function (value) {
              setTimeout(function () {
                me.tb.setValue(value);
              });
            });
          });

          if (me.querySettingsdata.length != 0 && !this.initialdata) {
            this.getRemoteClusterName();
            this.initialLoadValue = true;
            this.requestUUID = this.getRequestId();
            var queryContext = {
              "request_id": this.requestUUID,
              "query_win_size": this.qureyWindowSize,
              "query_start_time": moment_timezone__WEBPACK_IMPORTED_MODULE_17__().valueOf(),
              "query_op": "Execute",
              "log_level": this.queryLogLevel
            };
            this.previousQuery = "*|dedup log_key";
            this.previousIndex = "*";
            this.prevMinusFilter = JSON.stringify(this.minus_arr);
            this.prevPlusFilster = JSON.stringify(this.plus_arr);
            this.prevExistFilter = JSON.stringify(this.exist_arr);
            this.prevGteValue = this.tb.getValue().time.frameStart.value;
            this.prevLteValue = this.tb.getValue().time.frameEnd.value;
            this.prevSortValue = this.sortoptionsvalue;
            var winNumObj = {
              "sendDoc": "true",
              "page_num": 0,
              "page_size": this.pageSize
            };
            this.isRequestCancelled = false;
            this.nf.clientMsearch("*", "*|dedup log_key", this.tb.getValue().time.frameStart.value, this.tb.getValue().time.frameEnd.value, this.sorting, 50, this.pipetemindexvalue, this.tracktotalhitsvalue, this.sourceformatvalue.join(','), this.plus_arr, this.minus_arr, this.exist_arr, this.maxDocs, this.isLargeDataSet, this.responseformat, this.interval, sessionStorage.getItem('_nvtimezone'), this.sortoptionsvalue, this.clusterName, this.savedExtractFields, queryContext, winNumObj, this.logSource).subscribe(function (state) {
              if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["LogsLoadingState"]) {
                _this13.oninitialLoading(state);

                return;
              }

              if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["LogsLoadedState"]) {
                if (state.data['QueryContext'].QueryStatus == 'Processing') {
                  _this13.getProcessedRecords("true");
                }

                return;
              }
            }, function (state) {
              _this13.oninitialLoadingError(state);
            });
          }
        }
      }, {
        key: "oninitialLoading",
        value: function oninitialLoading(state) {
          var me = this;
          me.data.data = null;
          me.error = null;
          me.loading = true;
          me.isMenu = true;
          me.showingNoResult = false;
        }
      }, {
        key: "oninitialLoadingError",
        value: function oninitialLoadingError(state) {
          var _this14 = this;

          var _a, _b, _c, _d, _e;

          var me = this;
          me.data.data = null;
          me.error = state.error;
          me.loading = false;
          me.searchVal = false;
          me.clearVal = false;
          me.showingNoResult = true;
          me.isMenu = false;
          me.Error = ((_b = (_a = state === null || state === void 0 ? void 0 : state.error['error']) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.substring(0, 34)) + ' ...';
          me.isCustomError = true;
          me.logsCountLoading = false;
          me.showFullError = (_c = state === null || state === void 0 ? void 0 : state.error['error']) === null || _c === void 0 ? void 0 : _c.text;
          this.isShowMoreBtn = ((_e = (_d = state === null || state === void 0 ? void 0 : state.error['error']) === null || _d === void 0 ? void 0 : _d.text) === null || _e === void 0 ? void 0 : _e.length) > 33 ? true : false;
          this.timerId = setTimeout(function () {
            _this14.isCustomError = false;
          }, 10000);
        }
      }, {
        key: "oninitialLoaded",
        value: function oninitialLoaded(state) {
          var _this15 = this;

          var me = this;
          document.getElementById('searchQuery')['value'] = '';
          this.query = 'index=* query=*|dedup log_key';
          me.data.data = state.data;

          if (window['logLevel'] > 0) {
            console.log(me.data.data);
          }

          this.clearVal = false;
          me.loading = false;
          me.isMenu = false;
          this.showProgressBar = true;
          this.displayProcessDoc = true;

          if (me.data.data.tableData.length != undefined) {
            me.data.data.tableData.forEach(function (element) {
              _this15.selectRow[element.no] = 0;
            });
          }

          if (this.isDedupChecked && !this.query.includes("|dedup log_key")) {
            var subQuery = this.query.substring(0, this.query.length + 1);
            this.query = subQuery + "|dedup log_key";
          }

          if (this.query.includes('|dedup log_key') && this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Count';
          }) == false) {
            this.cacheSearchbarQuery = this.query;
            this.cacheSearchBarVisibleQuery = '';
            this.dedupQuery();
          }

          if (this.query.includes('|dedup log_key')) {
            this.cacheLogData = state.data['tableData'];
          }

          this.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];

          if (state.data['response']) {
            this.hitsValue = 0;
            this.showingNoResult = true;
            me.messageService.add({
              severity: 'error',
              summary: state.data['response'],
              sticky: false,
              life: 10000
            });
          } else {
            if (this.timestamp_type_value == 'true' && me.data.data.timestampWarn != '') {
              var message = 'Skipping these indices [' + me.data.data.timestampWarn + '] because @timestamp field is not of date type';
              me.messageService.add({
                severity: 'warn',
                summary: message,
                sticky: false,
                life: 10000
              });
            }

            this.onaggLoaded(state);
            this.onFieldsLoaded(state);
          }
        }
      }, {
        key: "getRequestId",
        value: function getRequestId() {
          return Object(uuid__WEBPACK_IMPORTED_MODULE_31__["v4"])();
        }
      }, {
        key: "setAutoCompleteTextInQuery",
        value: function setAutoCompleteTextInQuery() {
          if (this.switchTab != 'exception') {
            this.showProgressBar = true;
            this.displayProcessDoc = true;
          }

          if (document.getElementById('searchQuery')['value'] == '') {
            this.query = this.isDedupChecked == true ? "index=* query=*|dedup log_key" : "index=* query=*";
          } else {
            this.query = document.getElementById('searchQuery')['value'].trimStart();
            this.isDedupChecked = false;
          }

          this.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];
        }
      }, {
        key: "selectedSuggestion",
        value: function selectedSuggestion(val) {
          this.isSuggSelected = true;
          this.selectedSuggestionval = val;

          if (val == '<fieldValue>') {
            var _final = this.prevSuggestedQuery;
            document.getElementById('searchQuery')['value'] = _final;
            this.searchbarVisibleQuery = _final;
            return;
          }

          if (val == '[') {
            this.leftSqrBracePresent = true;
          }

          if (val == ']') {
            this.leftSqrBracePresent = false;
          }

          this.prevSuggestedQuery = this.prevSuggestedQuery.trimEnd();

          var _final2;

          if (this.prevSuggestedQuery.endsWith('stats') || this.prevSuggestedQuery.endsWith('docstats') || this.prevSuggestedQuery.endsWith('streamstats') || val.toLowerCase() == 'starttime' || val.toLowerCase() == 'endtime' || val == 'by' || val.toLowerCase() == 'span' || this.prevSuggestedQuery.endsWith('sort') || this.prevSuggestedQuery.endsWith('merge') || val == 'limit' || this.prevSuggestedQuery.endsWith('join') || this.prevSuggestedQuery.endsWith('on') || this.prevSuggestedQuery.endsWith('left') || this.prevSuggestedQuery.endsWith('inner') || val == 'maxmatch' || val == 'override' || val.toLowerCase() == 'as' || this.prevSuggestedQuery.endsWith('fetchlog')) {
            _final2 = this.prevSuggestedQuery + ' ' + val;
          } else {
            _final2 = this.prevSuggestedQuery + val;
          }

          document.getElementById('searchQuery')['value'] = _final2;
          this.searchbarVisibleQuery = _final2;
        }
      }, {
        key: "keyPress",
        value: function keyPress(e) {
          if (e.code == 'Backspace') {
            this.isBackspaceBtnPressed = true;
          } else {
            this.isBackspaceBtnPressed = false;
          }
        }
      }, {
        key: "convertNumberIntoFormat",
        value: function convertNumberIntoFormat(value) {
          value += '';
          value = value.replace(/,/g, '');
          var formatter = this.pipeService.getFormatter('num_en_us');
          if (formatter) return formatter.transform(value);
        }
      }, {
        key: "filterFields",
        value: function filterFields(event) {
          var _a;

          var filtered = [];
          this.isFieldValue = false;
          var query = event.query;
          var queryArray = query.split('');

          for (var i = 0; i < this.data.autocompleteData.length; i++) {
            var reportitem = this.data.autocompleteData[i];

            if (reportitem.name.toLowerCase().indexOf(query.toLowerCase()) == 0) {
              filtered.push(reportitem);
            }
          }

          var deletedSugg = this.prevSuggestedQuery.slice(document.getElementById('searchQuery')['value'].length);

          if (window['logLevel'] > 0) {
            console.log("deleted sugg:::", deletedSugg);
          }

          if (deletedSugg == ']' && this.isBackspaceBtnPressed == true) {
            this.leftSqrBracePresent = true;
          }

          this.prevSuggestedQuery = query;
          var suggestion = this.indexRef.parse(query, this.selectedSuggestionval);

          if ((suggestion.suggestion.indexOf(']') > -1 || suggestion.suggestion.indexOf('[') > -1) && suggestion.suggestion.indexOf('|') > -1) {
            lodash__WEBPACK_IMPORTED_MODULE_13__["pull"](suggestion.suggestion, ']');
            lodash__WEBPACK_IMPORTED_MODULE_13__["pull"](suggestion.suggestion, '[');
          }

          if (this.leftSqrBracePresent == true && suggestion.suggestion.indexOf(']') == -1) {
            suggestion.suggestion.push(']');
          }

          if (this.prevSuggestedQuery.trimEnd().endsWith('first') && suggestion.suggestion.indexOf('first') > -1 || this.prevSuggestedQuery.trimEnd().endsWith('last') && suggestion.suggestion.indexOf('last') > -1) {
            suggestion.suggestion.splice(suggestion.suggestion.indexOf('first'), 1);
            suggestion.suggestion.splice(suggestion.suggestion.indexOf('last'), 1);
          }

          if (this.isDedupChecked == true && suggestion.suggestion.indexOf('table') > -1) {
            if (window['logLevel'] > 0) {
              console.log("remove table option from suggestion when logs are grouped");
            }

            suggestion.suggestion.splice(suggestion.suggestion.indexOf('table'), 1);
          }

          if (window['logLevel'] > 0) {
            console.log("suggestion.suggestion", suggestion.suggestion);
          }

          var arr = [];
          var isSingleCharacterPresent;
          (_a = suggestion === null || suggestion === void 0 ? void 0 : suggestion.suggestion) === null || _a === void 0 ? void 0 : _a.forEach(function (element, idx) {
            //check suggestion consist of single character or not.
            if (/^[a-zA-Z_-]$/.test(element) == false) {
              //check for single digit
              if (/\d/.test(element) == false) {
                arr.push(element);
              }
            } else {
              isSingleCharacterPresent = true;
            }
          });

          if (isSingleCharacterPresent == true) {
            arr.splice(0, 0, '<fieldValue>');
          }

          this.autoSuggestions = arr;
          this.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];
          this.filteredReports = filtered;
        }
      }, {
        key: "plus_filter",
        value: function plus_filter(event) {
          if (window['logLevel'] > 0) {
            console.log(event);
          }

          for (var i = 0; i < event.length; i++) {
            this.plus_arr.push(event[i]);
          }

          this.gte = undefined;
          this.lte = undefined;
          this.fetchData();
        }
      }, {
        key: "minus_filter",
        value: function minus_filter(event) {
          if (window['logLevel'] > 0) {
            console.log(event);
          }

          for (var i = 0; i < event.length; i++) {
            this.minus_arr.push(event[i]);
          }

          this.gte = undefined;
          this.lte = undefined;
          this.fetchData();
        }
      }, {
        key: "exist_filter",
        value: function exist_filter(event) {
          if (window['logLevel'] > 0) {
            console.log(event);
          }

          this.exist_arr.push(event);
          this.gte = undefined;
          this.lte = undefined;
          this.fetchData();
        }
      }, {
        key: "clearQuery",
        value: function clearQuery() {
          var me = this;
          document.getElementById('searchQuery')['value'] = '';
          this.searchbarVisibleQuery = '';

          if (this.switchTab == 'exception') {
            this.query = 'index=* query=*';
            this.onClearQueryException = !this.onClearQueryException;
            return;
          }

          this.query = 'index=* query=*|dedup log_key';
          this.isCustomTable = false;
          this.isCreateTable = false;
          this.gte = undefined;
          this.lte = undefined;
          this.plus_arr = [];
          this.minus_arr = [];
          this.exist_arr = [];
          this.chipsValues = [];
          this.isFilterBarShowing = false;
          this.title = '';
          this.saveSearchData.saveTitle = this.title;

          if (this.sortValue.includes('logsequence')) {
            this.sortValue = JSON.stringify([{
              '@timestamp': {
                order: 'desc',
                unmapped_type: 'boolean'
              }
            }]);
          }

          this.router.navigate([], {
            queryParams: {}
          });
          this.sortingFieldName = '';
          this.isDedupChecked = true;
          this.isGroupSimilar = false;
          this.toggleColumnOption[0].toggleColSelectedOption = false;
          this.toggleColumnOption[1].toggleColSelectedOption = false;
          this.tableHeight = 509;
          this.isFromDDR = false;
          this.isDisableAll = true;
          this.fetchData();
          this.clearVal = true;
          this.similerLogHiglight = false;
          this.similerMessage = null;
        }
      }, {
        key: "showFilter",
        value: function showFilter() {
          this.isFilterBarShowing = !this.isFilterBarShowing;

          if (this.isFilterBarShowing == true) {
            if (this.isHistogramToggle == false && this.isActionOption == false) {
              this.tableHeight = 471;
            } else {
              if (this.histogramTable == false) {
                this.tableHeight = 265;
              }

              if (this.histogramTable == true) {
                this.tableHeight = this.visualTableHeight;
              }

              if (this.isRequest == true) {
                this.tableHeight = 282;
              }

              if (this.isResponse == true) {
                this.tableHeight = 282;
              }

              if (this.isStatistic == true) {
                this.tableHeight = 343;
              }
            }
          } else {
            this.tableHeight = 509;
          }
        }
      }, {
        key: "zoomfun",
        value: function zoomfun(val) {
          var zoomarr = Object.values(val);
          zoomarr = zoomarr.sort(function (a, b) {
            return a > b ? 1 : -1;
          });

          if (typeof this.gte != "number" && typeof this.lte != "number") {
            var convertedTimeStamp = this.convertGteLteInToTimestamp(this.gte.toString(), this.lte.toString());
            this.gte = convertedTimeStamp.gte;
            this.lte = convertedTimeStamp.lte;
          }

          if (val.undoZoom == false) {
            this.getTimeValuesBeforeZoom.push({
              gte: this.gte,
              lte: this.lte
            });
          }

          this.gte = zoomarr[1];
          this.lte = zoomarr[2];
          this.zoomCheck = true;
          this.fetchData();
        }
      }, {
        key: "closeItem",
        value: function closeItem() {
          if (this.showExpandedDiv) {
            this.showExpandedDiv = false;
          }

          if (this.isHistogramToggle == true) {
            this.isHistogramToggle = false;
          }

          this.isActionOption = false;
          this.tableHeight = this.isFilterBarShowing ? 471 : 509;
        }
      }, {
        key: "histrogramToggle",
        value: function histrogramToggle() {
          this.histogramTable = !this.histogramTable;
          this.isActionOption = false;
          this.isHistogramToggle = true;

          if (this.showExpandedDiv == false) {
            this.showExpandedDiv = true;
          }

          if (this.histogramTable == false) {
            this.tableHeight = this.isFilterBarShowing == true ? 265 : 509;
          } else {
            this.tableHeight = this.isFilterBarShowing == true ? this.visualTableHeight : 509;
          }
        }
      }, {
        key: "getActionMenuItem",
        value: function getActionMenuItem(name) {
          if (name == 'Show Extracted Fields') {
            this.openExitExtractedFields();
          }

          if (name == 'Export') {
            this.exportAsCSV();
          }

          if (name == 'Show Request') {
            this.isRequest = true;
            this.isActionOption = true;
            this.showExpandedDiv = true;
            this.isResponse = false;
            this.isStatistic = false;
            this.isHistogramToggle = false;
            this.tableHeight = this.isFilterBarShowing == true ? 282 : 509;
          }

          if (name == 'Show Response') {
            this.isResponse = true;
            this.isActionOption = true;
            this.showExpandedDiv = true;
            this.isRequest = false;
            this.isStatistic = false;
            this.isHistogramToggle = false;
            this.tableHeight = this.isFilterBarShowing == true ? 282 : 509;
          }

          if (name == 'Show Statistic') {
            this.isStatistic = true;
            this.isActionOption = true;
            this.showExpandedDiv = true;
            this.isRequest = false;
            this.isResponse = false;
            this.isHistogramToggle = false;
            this.tableHeight = this.isFilterBarShowing == true ? 343 : 509;
          }
        }
      }, {
        key: "getFpi",
        value: function getFpi(tabData, isCheckForFpi) {
          var fp = tabData.filter(function (ele) {
            return ele.label == 'fp';
          });

          if (fp.length > 0) {
            if (isCheckForFpi == true) {
              return true;
            }

            return fp[0].value.split(':')[1];
          } else {
            return false;
          }
        }
      }, {
        key: "menu",
        value: function menu($event, row) {
          var _a; //it prevents from multiple menu_bar.


          if (this.menu_bar != '') {
            this.menu_bar.hide();
          }

          var text = document.getSelection().toString();

          if (window['logLevel'] > 0) {
            console.log('row', row);
            console.log($event);
            console.log(text);
          }

          if (text == '') {
            this.menu_bar = '';
            return;
          }

          this.menu_bar = $($event.currentTarget).find('.ul-menu');
          this.isMenuVisible = true;
          var selectedRange = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.getRangeAt(0);

          if ((selectedRange === null || selectedRange === void 0 ? void 0 : selectedRange.startOffset) != (selectedRange === null || selectedRange === void 0 ? void 0 : selectedRange.endOffset)) {
            this.selectedTextStartIdx = selectedRange === null || selectedRange === void 0 ? void 0 : selectedRange.startOffset;
          }

          row.response.forEach(function (element) {
            if (text == element.label) {
              text = '';
            }
          });
          this.menu_bar.attr('x', text);
          this.menu_bar.css({
            left: $event.x + 'px',
            top: $event.y + 'px'
          });
          this.menu_bar.show();
        }
      }, {
        key: "getMenuItem",
        value: function getMenuItem(name, rowsData, row) {
          if (name == 'Show All Logs by fpi') {
            this.NDNVIntegration('nf', rowsData);
          }

          if (name == 'Open Transaction By fpi') {
            this.NDNVIntegration('nd', rowsData);
          }

          if (name == 'Open Timing by fpi') {
            this.NDNVIntegration('nvt', rowsData);
          }

          if (name == 'Open Replay by fpi') {
            this.NDNVIntegration('nvr', rowsData);
          }

          if (name == 'Follow log stream' && this.showSimilarDataFollowLogStream == false) {
            this.getAllInstance(row);
          }

          if (name == 'Follow log stream' && this.showSimilarDataFollowLogStream == true) {
            this.getSimilerData(row);
          }
        }
      }, {
        key: "openMenu",
        value: function openMenu(response, isCheckForFpi) {
          var temp = this.getFpi(response, isCheckForFpi);

          if (temp == true) {
            this.ddrItems = [{
              label: 'Show All Logs by fpi'
            }, {
              label: 'Open Transaction By fpi'
            }, {
              label: 'Open Timing by fpi'
            }, {
              label: 'Open Replay by fpi'
            }, {
              label: 'Follow log stream'
            }];
          } else {
            this.ddrItems = [{
              label: 'Follow log stream'
            }];
          }
        }
      }, {
        key: "NDNVIntegration",
        value: function NDNVIntegration(productName, rowsData) {
          var timestamp = rowsData.filter(function (ele) {
            return ele.label == '@timestamp';
          });
          var startTime = this.sessionService.convertFormattedStringIntoTimestamp(timestamp[0].value, 'YYYY-MM-DD “T” hh:mm:ss.SSSZ');
          var flowPath = rowsData.filter(function (ele) {
            return ele.label == 'fp';
          });
          var tier = rowsData.filter(function (ele) {
            return ele.label == 'tier';
          });
          var flowPathSplit = flowPath[0].value.split(':');

          if (productName == 'nd') {
            this._ddrData.isFromNF = '1';
            this._ddrData.flowpathID = flowPathSplit[1].match(/\d+/);
            this._ddrData.startTime = (startTime - 900000).toString(); // changes for 143941-- substract 15 minutes in stattime

            this._ddrData.endTime = (startTime + 900000).toString(); // add 15 minutes in endtime

            this._ddrData.testRun = flowPathSplit[0].match(/\d+/); // let nodeName;

            if (this.sessionService.preSession.multiDc) {
              // Remove tier dependency while DDR from NF to ND, 
              //as per ND team if dcName is '' ND will get the DC name on the basis of flowPathID
              // this.nf.getNodeInfoByTier(tier[0].value).subscribe((res) => { 
              // nodeName = res[tier[0].value][0];
              this._ddrData.dcName = '';
              this.router.navigate(['/ddr/flowpath']); // })
              // this._ddrData.getNodeInfo();
              // this._ddrData.dcName = this.sessionService.preSession.dcData
            } else {
              this.router.navigate(['/ddr/flowpath']);
            }
          } else if (productName == 'nvr') {
            if (flowPathSplit[4] && flowPathSplit[4] != 0 && flowPathSplit[4] != '') {
              this.router.navigate(['/netvision/play-sessions'], {
                queryParams: {
                  strOprName: 'replay',
                  testRun: flowPathSplit[0].match(/\d+/),
                  flowpathID: flowPathSplit[3] ? flowPathSplit[3].match(/\d+/) : flowPathSplit[1].match(/\d+/),
                  sid: flowPathSplit[4] ? flowPathSplit[4].match(/\d+/) : '',
                  pageInstance: flowPathSplit[5] ? flowPathSplit[5].match(/\d+/) : 0,
                  strStartTime: startTime
                }
              });
            } else {
              this.messageService.add({
                severity: 'error',
                summary: 'Node Error',
                detail: 'NV Session id is not Available or 0',
                sticky: false,
                life: 10000
              });
            }
          } else if (productName == 'nvt') {
            if (flowPathSplit[4] && flowPathSplit[4] != 0 && flowPathSplit[4] != '') {
              this.router.navigate(['/netvision/page-detail'], {
                queryParams: {
                  strOprName: 'timing',
                  testRun: flowPathSplit[0].match(/\d+/),
                  flowpathID: flowPathSplit[3] ? flowPathSplit[3].match(/\d+/) : flowPathSplit[1].match(/\d+/),
                  sid: flowPathSplit[4] ? flowPathSplit[4].match(/\d+/) : '',
                  pageInstance: flowPathSplit[5] ? flowPathSplit[5].match(/\d+/) : 0,
                  strStartTime: startTime
                }
              });
            } else {
              this.messageService.add({
                severity: 'error',
                summary: 'Node Error',
                detail: 'NV Session id is not Available or 0',
                sticky: false,
                life: 10000
              });
            }
          } else {
            this.query = 'index=* query=fpi:"' + flowPathSplit[1].match(/\d+/) + '"';
            document.getElementById('searchQuery')['value'] = 'fpi:"' + flowPathSplit[1].match(/\d+/) + '"';
            this.fetchData();
          }
        }
      }, {
        key: "addTableColumn",
        value: function addTableColumn(field) {
          var _this16 = this;

          if (window['logLevel'] > 0) {
            console.log('field is adding:;', field);
          }

          var fieldObj;
          this.expandedRows = {}; //collapse all rows of table.

          this.data.data.tableData.forEach(function (element) {
            _this16.selectRow[element.no] = 0;
          });

          if (this.isCreateTable == false || this.isCustomTable == false) {
            if (window['logLevel'] > 0) {
              console.log('table added first time');
            }

            this.isCreateTable = true;

            if (this.query.includes('|table')) {
              this.isCustomTable = true;
            }

            this.data.headers[0].cols.forEach(function (element, index) {
              if (element.label == 'Log Information') {
                _this16.data.headers[0].cols.splice(index, 1);
              }
            });
          }

          var colLength = this.data.headers[0].cols.length;
          fieldObj = {
            label: field,
            valueField: field,
            classes: 'text-left',
            badgeField: true,
            width: '30%',
            hidden: 'true'
          };
          var fixColumn = 0;

          if (this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Count';
          })) {
            fixColumn++;
          }

          if (this.data.headers[0].cols.some(function (ele) {
            return ele.label == '';
          })) {
            fixColumn++;
          }

          this.data.headers[0].cols.splice(colLength - fixColumn, 0, fieldObj);
        }
      }, {
        key: "deleteTableColumn",
        value: function deleteTableColumn(removeField) {
          var _this17 = this;

          if (window['logLevel'] > 0) {
            console.log('field is adding:;', removeField);
          }

          this.expandedRows = {}; //collapse all rows of table.

          this.data.data.tableData.forEach(function (element) {
            _this17.selectRow[element.no] = 0;
          });

          if (this.query.includes('|table')) {
            this.isCustomTable = false;
          }

          if (this.isCreateTable == false || this.isCustomTable == false) {
            if (window['logLevel'] > 0) {
              console.log('table added first time');
            }

            this.isCreateTable = true;
            this.data.headers[0].cols.forEach(function (element, index) {
              if (element.label == removeField) {
                _this17.data.headers[0].cols.splice(index, 1);
              }
            });
          }

          this.conditionToAddLogInformation();
        }
      }, {
        key: "sorting_order",
        value: function sorting_order(name) {
          if (name == 'keyword' || name == 'icon' || name == 'Time Diff' || name == 'Elapsed Time' || name == '' || name == undefined || name == 'doc_count') {
            return;
          }

          this.sorting_input = !this.sorting_input;
          this.gte = undefined;
          this.lte = undefined;
          this.sortingFieldName = name;
          this.isSorting = false;
          this.fetchData();
          this.clearVal = false;
        }
      }, {
        key: "searchData",
        value: function searchData() {
          if (this.isSuggSelected == false) {
            this.gte = undefined;
            this.lte = undefined;
            this.fetchData();
            this.onClearQueryException = !this.onClearQueryException;
            this.clearVal = false;
          } else {
            this.isSuggSelected = false;
          }
        }
      }, {
        key: "getSimilerData",
        value: function getSimilerData(row) {
          var _this18 = this;

          var index = this.query.substring(this.query.indexOf('=') + 1, this.query.indexOf('query')).trim();
          var queryValue;

          if (this.query.includes('|dedup log_key')) {
            queryValue = this.query.substring(this.query.indexOf('query=') + 6, this.query.indexOf('|dedup log_key')).startsWith('*') ? this.query.substring(this.query.indexOf('query=') + 7, this.query.indexOf('|dedup log_key')) : this.query.substring(this.query.indexOf('query=') + 6, this.query.indexOf('|dedup log_key'));
          } else {
            queryValue = this.query.substring(this.query.indexOf('query=') + 6).startsWith('*') ? this.query.substring(this.query.indexOf('query=') + 7) : this.query.substring(this.query.indexOf('query=') + 6);
          }

          row.response.forEach(function (res, index) {
            if (res.label == 'message') {
              _this18.similerMessage = res.value;
              _this18.similerMessageVal = res.value;
            }

            if (res.label == 'log_stream') {
              if (res.value.includes('mark')) {
                _this18.logStreamVal = res.value.replace(/<mark>/g, '').replace(/<\/mark>/g, '');
              } else {
                _this18.logStreamVal = res.value;
              }
            }
          }); //log stream already present,then remove it and update with new log stream value

          if (queryValue.startsWith('log_stream:')) {
            queryValue = queryValue.substring(queryValue.indexOf(this.logStreamVal) + this.logStreamVal.length + 1);
          }

          if (window['logLevel'] > 0) {
            console.log('queryValue===========', queryValue);
          }

          if (this.isFromDDR == true && queryValue.startsWith(this.ddrQueryValue) || queryValue != '' && queryValue.startsWith(' AND ') == false && queryValue.startsWith('|') == false) {
            queryValue = ' AND ' + queryValue;
          }

          if (window['logLevel'] > 0) {
            console.log('similer message is::', this.similerMessage);
          }

          var timeStamp = this.sessionService.convertFormattedStringIntoTimestamp(row.Time, 'YYYY-MM-DD “T” hh:mm:ss.SSSZ');
          this.query = 'index=' + index + ' query=log_stream:' + '"' + this.logStreamVal + '"' + queryValue;

          if ((document.getElementById('searchQuery')['value'].includes('index=') && document.getElementById('searchQuery')['value'].includes('query=')) == true) {
            document.getElementById('searchQuery')['value'] = this.query;
          } // show * only when given by user in querybar
          else {
            document.getElementById('searchQuery')['value'] = (document.getElementById('searchQuery')['value'].startsWith('*') == false && queryValue.startsWith('*') == true) == true ? 'log_stream:' + '"' + this.logStreamVal + '"' + queryValue.substring(1) : 'log_stream:' + '"' + this.logStreamVal + '"' + queryValue;
          }

          this.gte = timeStamp - this.logstreamWindow;
          this.lte = timeStamp + this.logstreamWindow;
          this.similerLogHiglight = true;
          this.similerLogHiglightVal = true;
          this.fetchData();
          this.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];
        } //Don't display the * untill it it not given manually by user in query bar

      }, {
        key: "displaySearchbarQuery",
        value: function displaySearchbarQuery(str1, str2) {
          if ((document.getElementById('searchQuery')['value'].includes('index=') && document.getElementById('searchQuery')['value'].includes('query=')) == false) {
            if (this.query.includes('|dedup log_key')) {
              document.getElementById('searchQuery')['value'] = (document.getElementById('searchQuery')['value'].startsWith('*') == false && str1.startsWith('*') == true) == true ? str1.substring(1) : str1;
            } else {
              document.getElementById('searchQuery')['value'] = (document.getElementById('searchQuery')['value'].startsWith('*') == false && str2.startsWith('*') == true) == true ? str2.substring(1) : str2;
            }
          } else {
            document.getElementById('searchQuery')['value'] = this.query;
          }
        }
      }, {
        key: "setQuerySettingData",
        value: function setQuerySettingData(querySettingsdata) {
          var _this19 = this;

          querySettingsdata.forEach(function (element) {
            if (element.name == 'pipetempindex') {
              _this19.pipetemindexvalue = element.value;
            }

            if (element.name == 'sourceformat') {
              _this19.sourceformatvalue = element.value.split(',');
            }

            if (element.name == 'dateFormat:tz') {
              _this19.timeZone = element.value;
            }

            if (element.name == 'discover:sampleSize') {
              _this19.samplesizevalue = element.value;
            }

            if (element.name == 'sort:options') {
              _this19.sortoptionsvalue = element.value;
            }

            if (element.name == 'responseformat') {
              _this19.responseformat = element.value;
            }

            if (element.name == 'message_setting') {
              _this19.messageLength = element.value;
            }

            if (element.name == 'fetch_log_cluster_data') {
              _this19.fetchClusterData = element.value;
            }

            if (element.name == "query_progress_update_interval") {
              _this19.queryProgressUpdateInterval = element.value;
            }

            if (element.name == "query_log_level") {
              _this19.queryLogLevel = element.value;
            }

            if (element.name == "page_size") {
              _this19.pageSize = element.value;
            }

            if (element.name == "query_window_size") {
              _this19.qureyWindowSize = element.value;
            }

            if (element.name == 'follow_log_stream') {
              element.values = element.values == 'log' ? 2 : element.values;
              element.value = element.value == 'logstream' ? 'min' : element.value;

              if (element.value == 'min') {
                _this19.logstreamWindow = element.values * 60 * 1000;
              }

              if (element.value == 'hour') {
                _this19.logstreamWindow = element.values * 60 * 60 * 1000;
              }
            }

            if (element.name == '@timestamp_type') {
              _this19.timestamp_type_value = element.value;
            }

            if (element.name == "graph_update_interval") {
              _this19.graphUpdateInterval = element.value;
            }
          });
        }
      }, {
        key: "fetchData",
        value: function fetchData() {
          var _this20 = this;

          if (this.switchTab == 'exception') {
            this.exceptionGteValue = this.tb.getValue().time.frameStart.value;
            this.exceptionLteValue = this.tb.getValue().time.frameEnd.value;
            return;
          }

          this.processedCount = 0;
          this.totalCount = 0;
          this.hitsValue = 0;
          this.logsCountLoading = true;
          this.initialLoadValue = false;

          if (window['logLevel'] > 0) {
            console.log('interval is::', this.interval);
          }

          this.sorting = this.sorting_input == true ? 'desc' : 'asc';

          if (this.sortingFieldName == 'Time' || this.sortingFieldName == 'keyword' || this.sortingFieldName == 'icon') {
            this.sortoptionsvalue = JSON.stringify([{
              '@timestamp': {
                order: this.sorting,
                unmapped_type: 'boolean'
              }
            }]);
          } else if (this.sortingFieldName == undefined || this.sortingFieldName == '') {
            this.sortoptionsvalue = this.sortoptionsvalue;
          } else {
            this.sortoptionsvalue = JSON.stringify([_defineProperty({}, this.sortingFieldName, {
              order: this.sorting
            })]);
          }

          var index;
          var query;

          if (this.isDedupChecked && this.query.includes('|dedup log_key') == false && this.isFromSaveQuery == false) {
            var subQuery = this.query.substring(0, this.query.length + 1);
            this.query = subQuery + '|dedup log_key';
          }

          if (this.query.startsWith('fetch') == false && this.query != '') {
            if (this.query.includes('index=') == false && this.query.includes('query=') == false) {
              index = '*';

              if (this.query.startsWith('|')) {
                query = '*' + this.query;
                this.searchbarVisibleQuery = query; //don't show only |dedup log_key in the searchbar

                if (query != '*|dedup log_key') {
                  document.getElementById('searchQuery')['value'] = query;
                }
              } else {
                query = this.query;
              }

              this.query = 'index=' + index + ' query=' + query;
            } else {
              index = this.query.substring(this.query.indexOf('index=') + 6, this.query.indexOf('query=')).trim();
              query = this.query.substring(this.query.indexOf('query=') + 6);
              this.query = 'index=' + index + ' query=' + query;
            }
          }

          if (this.zoomCheck == false) {
            this.getTimeValuesBeforeZoom = [];
          }

          var from;
          var to;

          if (this.gte != undefined && this.lte != undefined) {
            if (this.isFromDDR) {
              this.showingNoResult = false;
              this.gte = this.gte.toString();
              this.lte = this.lte.toString();

              if (this.gte.includes('/') && this.lte.includes('/')) {
                var convertedTimeStamp = this.convertGteLteInToTimestamp(this.gte, this.lte);
                from = convertedTimeStamp.gte;
                to = convertedTimeStamp.lte;
              } else {
                from = parseInt(this.gte);
                to = parseInt(this.lte);
              }
            } else if (this.update_gte_lte_with_logstream == true) {
              from = this.gte;
              to = this.lte;
              this.update_gte_lte_with_logstream = false;
            } else if (this.zoomCheck == true) {
              from = this.gte;
              to = this.lte;
              this.zoomCheck = false;
            } else if (this.isFromSaveQuery) {
              from = this.gte;
              to = this.lte;
              this.isFromSaveQuery = false;
            } else if (this.similerLogHiglight) {
              if (typeof this.gte == 'string') {
                if (this.gte.includes('/')) {
                  var _convertedTimeStamp = this.convertGteLteInToTimestamp(this.gte, this.lte);

                  this.gte = _convertedTimeStamp.gte;
                  this.lte = _convertedTimeStamp.lte;
                }
              }

              from = this.gte;
              to = this.lte;
            } else {
              from = this.tb.getValue().time.frameStart.value;
              to = this.tb.getValue().time.frameEnd.value;
            }

            if (typeof this.gte == 'string') {
              if (!this.gte.includes('/')) {
                this.gte = this.sessionService.convertTimestampIntoFormattedString(parseInt(this.gte), 'MM/DD/YYYY HH:mm:ss');
                this.lte = this.sessionService.convertTimestampIntoFormattedString(parseInt(this.lte), 'MM/DD/YYYY HH:mm:ss');
              }
            } else {
              this.gte = this.sessionService.convertTimestampIntoFormattedString(this.gte, 'MM/DD/YYYY HH:mm:ss');
              this.lte = this.sessionService.convertTimestampIntoFormattedString(this.lte, 'MM/DD/YYYY HH:mm:ss');
            }
          } else {
            from = this.tb.getValue().time.frameStart.value;
            to = this.tb.getValue().time.frameEnd.value;
            this.gte = this.sessionService.convertTimestampIntoFormattedString(this.tb.getValue().time.frameStart.value, 'MM/DD/YYYY HH:mm:ss');
            this.lte = this.sessionService.convertTimestampIntoFormattedString(this.tb.getValue().time.frameEnd.value, 'MM/DD/YYYY HH:mm:ss');
          }

          if (window['logLevel'] > 0) {
            console.log(from);
          }

          this.showClock = this.tb.getValue().time.frameStart.value == from && this.tb.getValue().time.frameEnd.value == to ? false : true; //expanded table will be collapsed

          this.expandedRows = {};
          this.isCustomTable = false;
          this.searchVal = true;
          this.clearVal = false;

          if (this.previousQuery.includes('|table') == true && this.query.includes('|table') == false) {
            this.isCreateTable = false;
            this.isGroupSimilar = false;
          }

          if (this.isCreateTable == false) {
            this.data.headers[0].cols = JSON.parse(JSON.stringify(_service_logstab_dummy__WEBPACK_IMPORTED_MODULE_6__["LOGS_DATA"].headers[0].cols));
          }

          if (this.query.includes("stats") || this.query.includes("docstats") || this.query.includes("streamstats")) {
            if (window['logLevel'] > 0) {
              console.log("stats present");
            }

            this.data.headers[0].cols.some(function (ele, idx) {
              if (ele.label == 'Time') {
                _this20.data.headers[0].cols.splice(idx, 1);
              }
            });
          }

          var isTimeColumn = this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Time';
          }) == true ? true : false;

          if (this.toggleColumnOption[0].toggleColSelectedOption == true && this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Diff(ms)';
          }) == false) {
            var obj = this.getColumnObject('Diff(ms)', 'Time Diff', 'docClass');
            isTimeColumn == true ? this.data.headers[0].cols.splice(1, 0, obj) : this.data.headers[0].cols.splice(0, 0, obj);
          }

          if (this.toggleColumnOption[1].toggleColSelectedOption == true && this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Elapsed(ms)';
          }) == false && this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Diff(ms)';
          }) == false) {
            var _obj3 = this.getColumnObject('Elapsed(ms)', 'Elapsed Time', 'elapseClass');

            isTimeColumn == true ? this.data.headers[0].cols.splice(1, 0, _obj3) : this.data.headers[0].cols.splice(0, 0, _obj3);
          }

          if (this.toggleColumnOption[1].toggleColSelectedOption == true && this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Elapsed(ms)';
          }) == false && this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Diff(ms)';
          }) == true) {
            var _obj4 = this.getColumnObject('Elapsed(ms)', 'Elapsed Time', 'elapseClass');

            isTimeColumn == true ? this.data.headers[0].cols.splice(2, 0, _obj4) : this.data.headers[0].cols.splice(1, 0, _obj4);
          }

          this.data.headers[0].cols = JSON.parse(JSON.stringify(this.data.headers[0].cols));
          var indexpattern;
          var maxdoc_val;
          var query_string;

          if (this.query.indexOf('|table') > -1) {
            var tableField = [];
            this.isGroupSimilar = true;
            this.isCustomTable = true;
            this.data.headers[0].cols.splice(1, this.data.headers[0].cols.length - 1);
            var tableQuery = this.query.substring(this.query.indexOf('|table') + 7, this.query.length);

            if (window['logLevel'] > 0) {
              console.log('table query is:::', tableQuery);
            }

            tableField = tableQuery.split(',');
            tableField.forEach(function (field) {
              _this20.data.headers[0].cols.push({
                label: field,
                valueField: field,
                classes: 'text-left',
                badgeField: true,
                width: '30%'
              });
            });
            this.data.headers[0].cols.push({
              label: '',
              valueField: 'icon',
              classes: 'text-left',
              iconField: true,
              width: '15%'
            });
          }

          if (this.query.startsWith('fetch')) {
            this.isDedupChecked = false;
            this.isGroupSimilar = true;
            indexpattern = '*';
            this.query = this.query.includes('|dedup log_key') ? this.query.substring(0, this.query.indexOf('|dedup log_key')) : this.query;
            query_string = this.query;
            document.getElementById('searchQuery')['value'] = this.query;
          }

          if (this.query.includes('|dedup log_key') && this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Count';
          }) == false) {
            this.cacheSearchbarQuery = this.query;
            this.cacheSearchBarVisibleQuery = document.getElementById('searchQuery')['value'];
            this.isDedupChecked = true;
            this.dedupQuery();
          }

          if (this.query.includes('|dedup log_key') == false) {
            this.data.headers[0].cols.some(function (ele, index) {
              if (ele.label == 'Count') {
                if (window['logLevel'] > 0) {
                  console.log("dedup not present count col should be removed");
                }

                _this20.data.headers[0].cols.splice(index, 1);
              }
            });
          }

          if (this.query.includes('where log_key==') || this.query.includes('where log_key.keyword==')) {
            this.isWhereLog_key = true;
            this.sortValue = this.sortoptionsvalue;
            this.sortoptionsvalue = JSON.stringify([{
              '@timestamp': {
                order: this.sorting,
                unmapped_type: 'boolean'
              }
            }, {
              logsequence: {
                order: 'desc',
                unmapped_type: 'boolean'
              }
            }]);
          } else {
            if (this.isWhereLog_key) {
              this.sortoptionsvalue = this.sortValue;
              this.isWhereLog_key = false;
            }
          }

          if (this.query.startsWith('index=')) {
            indexpattern = this.query.split(" ")[0].split("=")[1];
            this.clusterIndex = this.query.split(' ')[0].split('=')[1];

            if (this.query.indexOf("maxdocs=") > -1) {
              maxdoc_val = this.query.split(" ")[1].split("=")[1];
              this.maxDocs = maxdoc_val;
              this.isLargeDataSet = true;
              query_string = this.query.substr(this.query.indexOf("query=") + 6, this.query.length);
            } else {
              this.isLargeDataSet = true;
              maxdoc_val = undefined;
              this.maxDocs = maxdoc_val;
              query_string = this.query.substr(this.query.indexOf("query=") + 6, this.query.length);
            }
          }

          this.clusterName = [];

          if (this.fetchClusterData == 'true') {
            for (var key in this.remotedata) {
              if (this.remotedata[key].num_nodes_connected != 0) {
                this.clusterName.push(key + ':' + this.clusterIndex);
              }
            }
          }

          this.logSource = 'nfdb_cluster';

          if (this.query.includes('loki')) {
            var _query = this.query.substring(this.query.indexOf('query=') + 6);

            var constructStartIdx = this.getConstructStartingIndex(_query); //loki query + construct query present

            if (constructStartIdx != -1) {
              var loki_query = _query.substring(0, constructStartIdx);

              var restOfQuery = _query.substring(constructStartIdx);

              if (restOfQuery.includes('append') || restOfQuery.includes('join')) {
                var match = restOfQuery.match(/\|(?:\s)*?(append|join)/);
                var appendOrJoinQueryStartIdx = match ? match.index : -1; // construct apart from join/append can come between loki query & join/append query 

                var inBtwQuery = ''; //after loki query next immediate construct is not append/join

                if (appendOrJoinQueryStartIdx != constructStartIdx) {
                  inBtwQuery = restOfQuery.substring(0, appendOrJoinQueryStartIdx);
                  restOfQuery = restOfQuery.substring(appendOrJoinQueryStartIdx);
                }

                var endIdxOfAppendOrJoinQuery = this.getEndingPointOfAppendOrJoinQuery(restOfQuery); //Query inside [] bracket of join/append

                var innerAppendOrJoinQuery = restOfQuery.substring(restOfQuery.indexOf('[') + 1, endIdxOfAppendOrJoinQuery); //getting the starting index of construct present inside [] bracket of join/append

                var innerConstructStartIdx = this.getConstructStartingIndex(innerAppendOrJoinQuery);

                if (innerConstructStartIdx != -1) {
                  var lokiQueryInsideSquareBracket = innerAppendOrJoinQuery.substring(0, innerConstructStartIdx);
                  var restOfQueryWithOutLokiInsideSquareBracket = innerAppendOrJoinQuery.substring(innerConstructStartIdx);

                  if (inBtwQuery == '') {
                    query_string = 'loki:<<' + loki_query + '>>' + restOfQuery.substring(0, restOfQuery.indexOf('[') + 1) + 'loki:<<' + lokiQueryInsideSquareBracket + '>>' + restOfQueryWithOutLokiInsideSquareBracket + restOfQuery.substring(endIdxOfAppendOrJoinQuery);
                  } else {
                    query_string = 'loki:<<' + loki_query + '>>' + inBtwQuery + restOfQuery.substring(0, restOfQuery.indexOf('[') + 1) + 'loki:<<' + lokiQueryInsideSquareBracket + '>>' + restOfQueryWithOutLokiInsideSquareBracket + restOfQuery.substring(endIdxOfAppendOrJoinQuery);
                  }
                } else {
                  //loki query;
                  if (inBtwQuery == '') {
                    query_string = 'loki:<<' + loki_query + '>>' + restOfQuery.substring(0, restOfQuery.indexOf('[') + 1) + 'loki:<<' + innerAppendOrJoinQuery + '>>' + restOfQuery.substring(endIdxOfAppendOrJoinQuery);
                  } else {
                    query_string = 'loki:<<' + loki_query + '>>' + inBtwQuery + restOfQuery.substring(0, restOfQuery.indexOf('[') + 1) + 'loki:<<' + innerAppendOrJoinQuery + '>>' + restOfQuery.substring(endIdxOfAppendOrJoinQuery);
                  }
                }
              } else {
                //Join & append not present in the query
                query_string = 'loki:<<' + loki_query + '>>' + restOfQuery;
              }
            } //only loki query present
            else {
              query_string = 'loki:<<' + _query + '>>';
            }

            this.logSource = 'loki_cluster';
          }

          if (this.querySettingsdata == null) {
            this.qs.initialsettings().subscribe(function (state) {
              if (state instanceof _query_settings_service_query_settings_state__WEBPACK_IMPORTED_MODULE_11__["QuerySettingsLoadingState"]) {
                _this20.onqueryDataLoading(state);

                return;
              }

              if (state instanceof _query_settings_service_query_settings_state__WEBPACK_IMPORTED_MODULE_11__["QuerySettingsLoadedState"]) {
                _this20.querySettingsdata = state.data;

                _this20.setQuerySettingData(_this20.querySettingsdata);

                _this20.processMsearchRequest(query_string, from, to, indexpattern);
              }
            }, function (state) {
              _this20.onqueryDataLoadingError(state);
            });
          } else {
            this.processMsearchRequest(query_string, from, to, indexpattern);
          }
        }
      }, {
        key: "getEndingPointOfAppendOrJoinQuery",
        value: function getEndingPointOfAppendOrJoinQuery(val) {
          var arr = [];

          for (var i = 0; i < val.length; i++) {
            if (val.charAt(i) == '[') {
              arr.push(val[i]);
            }

            if (val.charAt(i) == ']') {
              if (arr.length == 1) {
                arr.pop();
                return i;
              }

              arr.pop();
            }
          }
        }
      }, {
        key: "getConstructStartingIndex",
        value: function getConstructStartingIndex(query) {
          var match = query.match(/\|\s*(dedup|eval|rex|docstat|lookup|makemv|merge|mvexpand|nomv|sort|table|top|where|mvcombine|stats|streamstats|summarystats|append|join)/);
          return match ? match.index : -1;
        }
      }, {
        key: "getRemoteClusterName",
        value: function getRemoteClusterName() {
          var _this21 = this;

          this.remoteCluster.getRemoteCluster().subscribe(function (data) {
            if (data instanceof _nf_add_remote_cluster_nf_remote_cluster_service_nf_remote_cluster_state__WEBPACK_IMPORTED_MODULE_28__["NfRemoteClusterLoadedState"]) {
              _this21.remotedata = data.data['resp'];

              if (window['logLevel'] > 0) {
                console.log(new Date().toString().split(' (')[0], 'remoteclusterdata', _this21.remotedata);
              }
            }

            (function (error) {
              return console.log('error!', error);
            });

            return;
          });
        }
      }, {
        key: "cancelQueryRequest",
        value: function cancelQueryRequest(indexpattern, query, gte, lte, sortparams, size, pipetempindex, tracktotalhits, sourceFormat, plus_arr, minus_arr, exist_arr, maxdocVal, isLargeDataSet, responseformat, interval, timezone, sortBy, queryContext, winNumObj) {
          return Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__awaiter"])(this, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee() {
            var _this22 = this;

            return _regenerator().w(function (_context) {
              while (1) switch (_context.n) {
                case 0:
                  _context.n = 1;
                  return this.nf.clientMsearch(indexpattern, query, gte, lte, sortparams, 50, pipetempindex, tracktotalhits, sourceFormat, plus_arr, minus_arr, exist_arr, maxdocVal, isLargeDataSet, responseformat, interval, timezone, sortBy, this.clusterName, this.savedExtractFields, queryContext, winNumObj, this.logSource).subscribe(function (state) {
                    if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["LogsLoadingState"]) {
                      clearTimeout(_this22.clearGetDataRequest);
                      _this22.clearGetDataRequest = 0;
                      _this22.isRequestCancelled = true;
                      _this22.requestUUID = null;

                      _this22.onLoading(state);

                      return;
                    }

                    if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["LogsLoadedState"]) {
                      if (window['logLevel'] > 0) {
                        console.log('Request Cancelled Successfully');
                      }

                      _this22.isMenu = false;
                      _this22.searchVal = false;
                      _this22.clearVal = false;
                      _this22.loading = false;
                      _this22.isSorting = true;
                      _this22.displayProcessDoc = false;
                      _this22.showProgressBar = false;
                      return;
                    }
                  }, function (state) {
                    _this22.onLoadingError(state);
                  });

                case 1:
                  return _context.a(2);
              }
            }, _callee, this);
          }));
        }
      }, {
        key: "processMsearchRequest",
        value: function processMsearchRequest(query_string, from, to, indexpattern) {
          var _this23 = this;

          var queryOp = 'UpdateProgress';

          if (this.previousQuery != query_string || this.previousIndex != indexpattern || this.prevMinusFilter != JSON.stringify(this.minus_arr) || this.prevPlusFilster != JSON.stringify(this.plus_arr) || this.prevExistFilter != JSON.stringify(this.exist_arr) || this.prevGteValue != from || this.prevLteValue != to || this.prevSortValue != this.sortoptionsvalue || this.requestUUID == null) {
            this.matchedCount = 0;
            this.processedCount = 2;
            this.totalCount = 100;

            if (this.isRequestCancelled == false) {
              var queryContext = {
                "request_id": this.requestUUID,
                "query_win_size": this.qureyWindowSize,
                "query_start_time": moment_timezone__WEBPACK_IMPORTED_MODULE_17__().valueOf(),
                "query_op": "Cancel",
                "log_level": this.queryLogLevel
              };
              var winNumObj = {
                "sendDoc": "false",
                "page_num": 0,
                "page_size": this.pageSize
              };
              this.cancelQueryRequest(indexpattern, query_string, from, to, this.sorting, 50, this.pipetemindexvalue, this.tracktotalhitsvalue, this.sourceformatvalue.join(','), this.plus_arr, this.minus_arr, this.exist_arr, this.maxDocs, this.isLargeDataSet, this.responseformat, this.interval, sessionStorage.getItem('_nvtimezone'), this.sortoptionsvalue, queryContext, winNumObj);
            }

            this.previousQuery = query_string;
            this.previousIndex = indexpattern;
            this.prevMinusFilter = JSON.stringify(this.minus_arr);
            this.prevPlusFilster = JSON.stringify(this.plus_arr);
            this.prevExistFilter = JSON.stringify(this.exist_arr);
            this.prevGteValue = from;
            this.prevLteValue = to;
            this.prevSortValue = this.sortoptionsvalue;
            queryOp = 'Execute';
          }

          setTimeout(function () {
            if (queryOp == 'Execute') {
              _this23.requestUUID = _this23.getRequestId();

              if (_this23.showCacheButton == true) {
                _this23.showCacheButton = false;
              }
            }

            var queryContext = {
              "request_id": _this23.requestUUID,
              "query_win_size": _this23.qureyWindowSize,
              "query_start_time": moment_timezone__WEBPACK_IMPORTED_MODULE_17__().valueOf(),
              "query_op": queryOp,
              "log_level": _this23.queryLogLevel
            };
            var winNumObj = {
              "sendDoc": "true",
              "page_num": 0,
              "page_size": _this23.pageSize
            };
            _this23.searchVal = true;
            _this23.isRequestCancelled = false;

            _this23.nf.clientMsearch(indexpattern, query_string, from, to, _this23.sorting, _this23.samplesizevalue, _this23.pipetemindexvalue, _this23.tracktotalhitsvalue, _this23.sourceformatvalue != undefined ? _this23.sourceformatvalue.join(',') : '', _this23.plus_arr, _this23.minus_arr, _this23.exist_arr, _this23.maxDocs, _this23.isLargeDataSet, _this23.responseformat, _this23.interval, sessionStorage.getItem('_nvtimezone'), _this23.sortoptionsvalue, _this23.clusterName, _this23.savedExtractFields, queryContext, winNumObj, _this23.logSource).subscribe(function (state) {
              if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["LogsLoadingState"]) {
                _this23.onLoading(state);

                return;
              }

              if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["LogsLoadedState"]) {
                if (state.data && state.data['QueryContext'].QueryStatus == 'Processing') {
                  if (window['logLevel'] > 0) {
                    console.log('data fetched in if condition');
                  }

                  _this23.showProgressBar = true;
                  _this23.isRequestCancelled = false;
                  _this23.clearGetDataRequest = setTimeout(function () {
                    _this23.getProcessedRecords("true");
                  }, _this23.queryProgressUpdateInterval);
                }

                if (state.data && state.data['QueryContext'].QueryStatus == 'Completed') {
                  _this23.isMenu = false;
                  _this23.searchVal = false;
                  _this23.clearVal = false;
                  _this23.logsCountLoading = false;
                  _this23.loading = false;
                  _this23.isSorting = true;
                  _this23.hitsValue = _this23.matchedCount;
                  _this23.showProgressBar = false;
                  _this23.hitsValue = _this23.matchedCount;

                  if (_this23.hitsValue == 0) {
                    _this23.showingNoResult = true;
                  } else {
                    _this23.showingNoResult = false;
                  }
                }

                return;
              }
            }, function (state) {
              _this23.logsCountLoading = false;

              _this23.onLoadingError(state);
            });
          }, 500);
        }
      }, {
        key: "onLoading",
        value: function onLoading(state) {
          var me = this;
          me.error = null;
          me.loading = true;
          me.clearVal = true;
          me.searchVal = true;
          me.isMenu = true;
        }
      }, {
        key: "onLoadingError",
        value: function onLoadingError(state) {
          var _this24 = this;

          var _a, _b;

          var me = this;
          me.data.data = null;
          me.chartXaxisData = [];
          me.chartYaxisData = [];
          me.hitsValue = 0;
          me.Error = '';
          me.isCustomError = true;
          me.Error = state.error['error'].text == undefined || state.error['error'].text.length == 0 ? '' : state.error['error'].text.substring(0, 34) + ' ...';
          me.showFullError = state.error['error'].text;
          me.showingNoResult = true;
          me.isMenu = false;
          this.displayProcessDoc = false;
          this.showProgressBar = false;
          this.searchVal = false;
          this.loading = false;
          this.isShowMoreBtn = ((_b = (_a = state === null || state === void 0 ? void 0 : state.error['error']) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.length) > 33 ? true : false;
          this.timerId = setTimeout(function () {
            _this24.isCustomError = false;
          }, 10000);
        }
      }, {
        key: "onLoaded",
        value: function onLoaded(state) {
          var _this25 = this;

          var me = this;
          this.showProgressBar = true;
          this.displayProcessDoc = true;
          this.clearVal = false;
          me.loading = false;
          me.isMenu = false;
          this.isSorting = true;
          me.isDisableAll = false;

          if (state.data['displayName']) {
            me.messageService.add({
              severity: 'error',
              summary: state.data['displayName'],
              detail: state.data['message'],
              sticky: false,
              life: 10000
            });
          } else if (state.data['response']) {
            this.hitsValue = 0;
            this.showingNoResult = true;
            me.messageService.add({
              severity: 'error',
              summary: 'Error:-',
              detail: state.data['msg'],
              sticky: false,
              life: 10000
            });
          } else {
            me.data.data = state.data;

            if (this.query.includes("log_stream")) {
              this.logStreamFlag = true;
            } else {
              this.logStreamFlag = false;
            }

            this.logStreamValue = this.query.substring(this.query.indexOf('log_stream:') + 12, this.query.indexOf('"|') > -1 ? this.query.indexOf('"|') : this.query.length - 1); //for extracting log_stream value from query

            if (this.expandedRowData != '') {
              this.tableRef.expandedRowKeys[this.expandedRowData._id] = 0;
            }

            if (this.plus_arr.length == 0 && this.minus_arr.length == 0 && this.exist_arr.length == 0) {
              this.isFilterBarShowing = false;
              this.tableHeight = 509;
            }

            if ('tableData' in me.data.data) {
              if (this.query.includes('query=log_stream:') == false && this.similerLogHiglight == true) {
                this.similerLogHiglight = false;
                this.similerMessage = null;
                this.similerLogHiglightVal = false;
                this.similerMessageVal = null;
              }

              me.data.data.tableData.forEach(function (element, rowIndex) {
                _this25.selectRow[element.no] = 0;

                if (_this25.similerMessage != null) {
                  element.response.forEach(function (ele) {
                    if (ele.label == 'message' && ele.value == _this25.similerMessage) {
                      if (window['logLevel'] > 0) {
                        console.log('=====page value is::', rowIndex, rowIndex / 50, Math.ceil(rowIndex / 50));
                      }

                      _this25.first = (Math.ceil((rowIndex + 1) / 50) - 1) * 50 + 1;
                      _this25.first = _this25.first == 1 ? 0 : _this25.first;
                    }
                  });
                }
              });
            }

            if (this.isInstanceFollowLogStream == true && this.query.includes('where log_key==') || this.isInstanceFollowLogStream == true && this.query.includes('where log_key.keyword==') || this.isInstanceFollowLogStream == true) {
              this.showSimilarDataFollowLogStream = false;
              this.isInstanceFollowLogStream = false;
            } else {
              this.showSimilarDataFollowLogStream = true;
            }

            if (this.query.includes('log_stream:') && this.isCacheButton == true || this.query.includes('where log_key==') && this.isCacheButton == true || this.query.includes('where log_key.keyword==') && this.isCacheButton == true) {
              this.showCacheButton = true;
              this.isCacheButton = false;
            }

            if (this.query.includes('|dedup log_key')) {
              this.cacheLogData = this.data.data.tableData;
            }

            if (this.timestamp_type_value == 'true' && me.data.data.timestampWarn != '') {
              var message = 'Skipping these indices [' + me.data.data.timestampWarn + '] because @timestamp field is not of date type';
              me.messageService.add({
                severity: 'warn',
                summary: message,
                sticky: false,
                life: 10000
              });
            }

            this.onaggLoaded(state);
            this.onFieldsLoaded(state);
          }
        }
      }, {
        key: "onaggLoading",
        value: function onaggLoading(state) {
          var me = this;
          me.error = null;
          me.loading = true;
        }
      }, {
        key: "onaggLoaded",
        value: function onaggLoaded(state) {
          this.visualTableHeight = 405;

          if (window['logLevel'] > 0) {
            console.log(state);
          }

          this.chartYaxisData = state.data.chartData.data;
          this.chartXaxisData = this.nf.convertDataIntoTimeZoneData(state.data.chartData.timestamp);

          if (this.query.includes('|dedup log_key')) {
            this.cacheAggData = state.data.chartData;
            this.cacheXaxisData = this.chartXaxisData;
          }

          this.tabledata = state.data.chartData.tabledata;
          this.visualTableHeight = this.tabledata.length < 5 ? this.visualTableHeight - 30 : this.visualTableHeight;

          if (this.histogramTable == true && this.isHistogramToggle == true) {
            this.tableHeight = this.isFilterBarShowing == true ? this.visualTableHeight : 509;
          }

          if (window['logLevel'] > 0) {
            console.log('table height::::::::::', this.tableHeight);
          }

          this.stats = state.data.chartData.stats;
          this.loading = false;
          this.lastGraphUpdateTime = moment_timezone__WEBPACK_IMPORTED_MODULE_17__().valueOf();
        }
      }, {
        key: "onaggLoadingError",
        value: function onaggLoadingError(state) {
          var me = this;
          me.error = state.error;
          me.loading = true;
        }
      }, {
        key: "onFieldsLoading",
        value: function onFieldsLoading(state) {
          var me = this;
          me.error = null;
          me.loading = true;
        }
      }, {
        key: "onFieldsLoaded",
        value: function onFieldsLoaded(state) {
          var _this26 = this;

          if (window['logLevel'] > 0) {
            console.log(state);
          }

          state.data.fieldsData.forEach(function (element, index) {
            if (element.name == 'message' || element.name == '@timestamp' || element.fields.length == 0) {
              state.data.fieldsData.splice(index, 1);
            }
          });

          if (this.query.includes('|dedup log_key')) {
            this.cacheFieldsData = state.data.fieldsData;
          }

          this.fieldsdata = state.data.fieldsData;
          var isTimeColumn = false;
          var temp = this.data.headers[0].cols;
          var idx = 0;
          var isExternalColPresent;
          var logInfoColPresent;

          var _loop2 = function _loop2() {
            var isElementPresent = false;
            var element = temp[idx];

            if (element.label != 'Time' && element.label != '' && element.label != 'Count' && element.label != 'Diff(ms)' && element.label != 'Elapsed(ms)' && element.label != 'Log Information') {
              _this26.fieldsdata.forEach(function (ele) {
                if (ele.name == element.label) {
                  isElementPresent = true;
                  isExternalColPresent = true;
                  ele.isSelected = true;
                  idx++;
                }
              });

              if (isElementPresent == false) {
                if (window['logLevel'] > 0) {
                  console.log("element not exist in fields", element, idx);
                }

                temp.splice(idx, 1);
                idx = idx;
              }
            } else {
              if (element.label == 'Time') {
                isTimeColumn = true;
              }

              if (element.label == 'Log Information') {
                logInfoColPresent = true;
              }

              idx++;
            }
          };

          while (idx < temp.length) {
            _loop2();
          }

          if (isTimeColumn == false && this.query.includes('stats') == false) {
            var obj = {
              label: 'Time',
              valueField: 'Time',
              classes: 'timeCol',
              width: '10%',
              selected: true
            };
            this.data.headers[0].cols.splice(0, 0, obj);
          }

          if (isExternalColPresent != true && logInfoColPresent != true) {
            this.conditionToAddLogInformation();
          }

          if (this.fieldsdata.some(function (ele) {
            return ele.name == 'fp';
          })) {
            if (!this.data.headers[0].cols.some(function (ele) {
              return ele.label == '';
            })) {
              this.addIconColumn();
            }
          }

          this.loading = false;
        }
      }, {
        key: "onFieldsLoadingError",
        value: function onFieldsLoadingError(state) {
          var me = this;
          me.error = state.error;
          me.loading = true;
        }
      }, {
        key: "showFullErrorMsg",
        value: function showFullErrorMsg() {
          clearTimeout(this.timerId);
          this.Error = this.showFullError;
          this.isShowMoreBtn = false;
        }
      }, {
        key: "serviceMethodTiming",
        value: function serviceMethodTiming($event) {
          this.isOn = $event;
        }
      }, {
        key: "hotspotSummary",
        value: function hotspotSummary($event) {
          this.isOn = $event;
        }
      }, {
        key: "showDialog",
        value: function showDialog() {
          var _this27 = this;

          this.showSavedSearchDialog = true;
          this.savedSerchService.getSavedSearch().subscribe(function (state) {
            if (state instanceof _my_library_search_service_search_state__WEBPACK_IMPORTED_MODULE_22__["SavedSearchLoadingState"]) {
              _this27.onLoadingSearch(state);

              return;
            }

            if (state instanceof _my_library_search_service_search_state__WEBPACK_IMPORTED_MODULE_22__["SavedSearchLoadedState"]) {
              _this27.onLoadedSearch(state);

              return;
            }
          }, function (state) {
            _this27.onLoadingSearchError(state);
          });
        }
      }, {
        key: "onLoadingSearch",
        value: function onLoadingSearch(state) {
          var me = this;
          me.saveSearchedData = null;
        }
      }, {
        key: "onLoadingSearchError",
        value: function onLoadingSearchError(state) {
          var me = this;
          me.saveSearchedData = null;
        }
      }, {
        key: "onLoadedSearch",
        value: function onLoadedSearch(state) {
          var me = this;
          me.saveSearchedData = state.data;
        }
      }, {
        key: "closeDialog",
        value: function closeDialog() {
          this.showSavedSearchDialog = false;
        }
      }, {
        key: "openSearchData",
        value: function openSearchData(data) {
          var _this28 = this;

          if (data.sourceData.preset && data.sourceData.preset != '') {
            this.tb.loadTime(data.sourceData.preset).subscribe(function (state) {
              if (state instanceof src_app_shared_time_bar_service_time_bar_state__WEBPACK_IMPORTED_MODULE_29__["GlobalTimebarTimeLoadedState"]) {
                if (window['logLevel'] > 0) {
                  console.log("time period of log", state.data);
                }

                _this28.router.navigate(['/home/logs'], {
                  queryParams: {
                    query: data.sourceData.query,
                    gte: state.data[1],
                    lte: state.data[2],
                    title: data.name
                  }
                });
              }
            });
          } else {
            this.router.navigate(['/home/logs'], {
              queryParams: {
                query: data.sourceData.query,
                gte: data.sourceData.time.from,
                lte: data.sourceData.time.to,
                title: data.name
              }
            });
          }

          this.closeDialog();
        }
      }, {
        key: "toLogDetails",
        value: function toLogDetails(value) {
          this.isOn = true;
          this.RowData = value;

          if (window['logLevel'] > 0) {
            console.log(this.RowData);
          }

          this.rowClick.emit(this.isOn);
        }
      }, {
        key: "copyLabel",
        value: function copyLabel(item, isResponse) {
          var value = {
            label: ''
          };

          if (isResponse) {
            value.label = item;
          } else value = item;

          var queryKey = value.label.substring(0, value.label.indexOf(':'));

          if (queryKey == 'message' || queryKey == '@timestamp' || queryKey == '_score') {
            if (window['logLevel'] > 0) {
              console.log("do not add");
            }

            return;
          }

          var queryValue = value.label.substring(value.label.indexOf(':') + 1, value.label.length);

          if (queryValue.includes('mark')) {
            queryValue = queryValue.replace(/<mark>/g, '').replace(/<\/mark>/g, '');
          }

          this.badgeValue = queryKey + ':"' + queryValue + '"';

          if (this.query.includes('|')) {
            var preQuery = this.query.substring(0, this.query.indexOf('query=') + 6);
            var subQuery = this.query.substring(this.query.indexOf('query=') + 6, this.query.indexOf('|'));
            var restQuery = this.query.substring(this.query.indexOf('|'), this.query.length);

            if (subQuery.trim() == '*') {
              this.query = preQuery + this.badgeValue + restQuery;
            } else {
              if (subQuery.startsWith('*')) {
                //ignore *
                subQuery = this.query.substring(this.query.indexOf('query=') + 7, this.query.length);
              }

              this.query = preQuery + subQuery + ' AND ' + this.badgeValue + restQuery;
            }
          } else {
            var _preQuery = this.query.substring(0, this.query.indexOf('query=') + 6);

            var _subQuery = this.query.substring(this.query.indexOf('query=') + 6, this.query.length);

            if (_subQuery.trim() == '*') {
              this.query = _preQuery + this.badgeValue;
            } else {
              if (_subQuery.startsWith('*')) {
                //ignore *
                _subQuery = this.query.substring(this.query.indexOf('query=') + 7, this.query.length);
              }

              this.query = this.query + ' AND ' + this.badgeValue;
            }
          }

          var str1 = this.query.substring(this.query.indexOf('query=') + 6, this.query.indexOf('|dedup log_key'));
          var str2 = this.query.substring(this.query.indexOf('query=') + 6);
          this.displaySearchbarQuery(str1, str2);
          this.fetchData();
          this.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];
          this.first = 0;
          this.clearVal = false;
        }
      }, {
        key: "copyText",
        value: function copyText($event) {
          if (window['logLevel'] > 0) {
            console.log($($event.target));
          }

          var text = $($event.target.parentElement).attr('x');
          if (text == '') return;
          this.selectedText = text;

          if (this.selectedText.includes('mark')) {
            this.selectedText = this.query.replace(/<mark>/g, '').replace(/<\/mark>/g, '');
          }

          if (this.query.includes('|')) {
            var preQuery = this.query.substring(0, this.query.indexOf('query=') + 6);
            var subQuery = this.query.substring(this.query.indexOf('query=') + 6, this.query.indexOf('|'));
            var restQuery = this.query.substring(this.query.indexOf('|'), this.query.length);

            if (subQuery.trim() == '*') {
              this.query = preQuery + '"' + this.selectedText + '"' + restQuery;
            } else {
              if (subQuery.startsWith('*')) {
                //ignore *
                subQuery = this.query.substring(this.query.indexOf('query=') + 7, this.query.length);
              }

              this.query = preQuery + subQuery + ' AND "' + this.selectedText + '"' + restQuery;
            }
          } else {
            var _preQuery2 = this.query.substring(0, this.query.indexOf('query=') + 6);

            var _subQuery2 = this.query.substring(this.query.indexOf('query=') + 6, this.query.length);

            if (_subQuery2.trim() == '*') {
              this.query = _preQuery2 + '"' + this.selectedText + '"';
            } else {
              if (_subQuery2.startsWith('*')) {
                //ignore *
                _subQuery2 = this.query.substring(this.query.indexOf('query=') + 7, this.query.length);
              }

              this.query = _preQuery2 + _subQuery2 + ' AND "' + this.selectedText + '"';
            }
          }

          var str1 = this.query.substring(this.query.indexOf('query=') + 6, this.query.indexOf('|dedup log_key'));
          var str2 = this.query.substring(this.query.indexOf('query=') + 6);
          this.displaySearchbarQuery(str1, str2);
          this.fetchData();
          this.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];
          this.clearVal = false;

          if (window['logLevel'] > 0) {
            console.log(this.chipsValues);
          }
        }
      }, {
        key: "addLogInformation",
        value: function addLogInformation(i) {
          this.isCreateTable = false;
          this.isCustomTable = false;
          var respCol = {
            label: 'Log Information',
            valueField: 'keyword',
            classes: 'text-left',
            badgeField: true,
            width: '70%'
          };
          this.data.headers[0].cols.splice(i, 0, respCol);
        }
      }, {
        key: "conditionToAddLogInformation",
        value: function conditionToAddLogInformation() {
          var res = this.existingColumnsInLogtable();

          if (window['logLevel'] > 0) {
            console.log("res::::", res);
          }

          if (this.data.headers[0].cols.length == 0 && res.isTimeColumn == false && res.isCountColumn == false && res.isIconColumn == false && res.isDiffColumn == false && res.isElapsedColumn == false) {
            this.addLogInformation(0);
          }

          if (this.data.headers[0].cols.length == 1 && res.isTimeColumn == false && res.isCountColumn == false && res.isIconColumn == false && (res.isDiffColumn == false && res.isElapsedColumn == true || res.isDiffColumn == true && res.isElapsedColumn == false)) {
            this.addLogInformation(1);
          }

          if (this.data.headers[0].cols.length == 2 && res.isTimeColumn == false && res.isCountColumn == false && res.isIconColumn == false && res.isDiffColumn == true && res.isElapsedColumn == true) {
            this.addLogInformation(2);
          }

          if (this.data.headers[0].cols.length == 1 && res.isTimeColumn == false && (res.isCountColumn == false && res.isIconColumn == true || res.isCountColumn == true && res.isIconColumn == false) && res.isDiffColumn == false && res.isElapsedColumn == false) {
            this.addLogInformation(0);
          }

          if (this.data.headers[0].cols.length == 2 && res.isTimeColumn == false && (res.isCountColumn == false && res.isIconColumn == true || res.isCountColumn == true && res.isIconColumn == false) && (res.isDiffColumn == false && res.isElapsedColumn == true || res.isDiffColumn == true && res.isElapsedColumn == false)) {
            this.addLogInformation(1);
          }

          if (this.data.headers[0].cols.length == 3 && res.isTimeColumn == false && (res.isCountColumn == false && res.isIconColumn == true || res.isCountColumn == true && res.isIconColumn == false) && res.isDiffColumn == true && res.isElapsedColumn == true) {
            this.addLogInformation(2);
          }

          if (this.data.headers[0].cols.length == 2 && res.isTimeColumn == false && res.isCountColumn == true && res.isIconColumn == true && res.isDiffColumn == false && res.isElapsedColumn == false) {
            this.addLogInformation(0);
          }

          if (this.data.headers[0].cols.length == 3 && res.isTimeColumn == false && res.isCountColumn == true && res.isIconColumn == true && (res.isDiffColumn == false && res.isElapsedColumn == true || res.isDiffColumn == true && res.isElapsedColumn == false)) {
            this.addLogInformation(1);
          }

          if (this.data.headers[0].cols.length == 4 && res.isTimeColumn == false && res.isCountColumn == true && res.isIconColumn == true && res.isDiffColumn == true && res.isElapsedColumn == true) {
            this.addLogInformation(2);
          }

          if (this.data.headers[0].cols.length == 1 && res.isTimeColumn == true && res.isCountColumn == false && res.isIconColumn == false && res.isDiffColumn == false && res.isElapsedColumn == false) {
            this.addLogInformation(1);
          }

          if (this.data.headers[0].cols.length == 2 && res.isTimeColumn == true && res.isCountColumn == false && res.isIconColumn == false && (res.isDiffColumn == false && res.isElapsedColumn == true || res.isDiffColumn == true && res.isElapsedColumn == false)) {
            this.addLogInformation(2);
          }

          if (this.data.headers[0].cols.length == 3 && res.isTimeColumn == true && res.isCountColumn == false && res.isIconColumn == false && res.isDiffColumn == true && res.isElapsedColumn == true) {
            this.addLogInformation(3);
          }

          if (this.data.headers[0].cols.length == 2 && res.isTimeColumn == true && (res.isCountColumn == false && res.isIconColumn == true || res.isCountColumn == true && res.isIconColumn == false) && res.isDiffColumn == false && res.isElapsedColumn == false) {
            this.addLogInformation(1);
          }

          if (this.data.headers[0].cols.length == 3 && res.isTimeColumn == true && (res.isCountColumn == false && res.isIconColumn == true || res.isCountColumn == true && res.isIconColumn == false) && (res.isDiffColumn == false && res.isElapsedColumn == true || res.isDiffColumn == true && res.isElapsedColumn == false)) {
            this.addLogInformation(2);
          }

          if (this.data.headers[0].cols.length == 4 && res.isTimeColumn == true && (res.isCountColumn == false && res.isIconColumn == true || res.isCountColumn == true && res.isIconColumn == false) && res.isDiffColumn == true && res.isElapsedColumn == true) {
            this.addLogInformation(3);
          }

          if (this.data.headers[0].cols.length == 3 && res.isTimeColumn == true && res.isCountColumn == true && res.isIconColumn == true && res.isDiffColumn == false && res.isElapsedColumn == false) {
            this.addLogInformation(1);
          }

          if (this.data.headers[0].cols.length == 4 && res.isTimeColumn == true && res.isCountColumn == true && res.isIconColumn == true && (res.isDiffColumn == false && res.isElapsedColumn == true || res.isDiffColumn == true && res.isElapsedColumn == false)) {
            this.addLogInformation(2);
          }

          if (this.data.headers[0].cols.length == 5 && res.isTimeColumn == true && res.isCountColumn == true && res.isIconColumn == true && res.isDiffColumn == true && res.isElapsedColumn == true) {
            this.addLogInformation(3);
          }
        }
      }, {
        key: "createMonitor",
        value: function createMonitor($event) {
          var _this29 = this;

          var paramQuery = '';
          var metricGroupName = 'LogMonitor';

          if (window['logLevel'] > 0) {
            console.log($($event.target));
          }

          var text = $($event.target.parentElement).attr('x');
          if (text == '') return;
          this.selectedText = text;

          if (this.query.includes('|')) {
            var subQuery = this.query.substring(this.query.indexOf('query=') + 6, this.query.indexOf('|'));
            var restQuery = this.query.substring(this.query.indexOf('|'), this.query.length);
            subQuery = subQuery + ' AND "' + this.selectedText + '"';
            paramQuery = subQuery + restQuery;
          } else {
            paramQuery = this.query.substring(this.query.indexOf('query=') + 6, this.query.length);
            paramQuery = paramQuery + ' AND "' + this.selectedText + '"';
          }

          metricGroupName += this.selectedText;

          if (window['logLevel'] > 0) {
            console.log('param query is::', paramQuery);
            console.log('metricGroupName is::', metricGroupName);
            console.log(this.customMonitorService);
          }

          this.customMonitorService.isFromEdit = true;
          this.customMonitorService.getNfEditData.gdfInfo.grpN = metricGroupName;
          this.customMonitorService.getNfEditData.gdfInfo.gD = metricGroupName;
          this.monUpDownStatus.getTierList().subscribe(function (res) {
            var id = [];
            var tName = [];
            res['data'] = _this29.monUpDownStatus.sort_by_key(res['data'], "tName");
            res['data'].map(function (each) {
              id.push(each['id']);
              tName.push(each['tName']);
            });

            var tierHeadersList = _monitor_up_down_status_service_utility_service__WEBPACK_IMPORTED_MODULE_24__["UtilityService"].createListWithKeyValue(tName, id);

            _this29.customMonitorService.setTierHeaderList(tierHeadersList);
          });
          this.customMonitorService.globalNf().subscribe(function (data) {
            _this29.customMonitorService['globalNFData'] = data;
            _this29.customMonitorService.getNfEditData.nf = data;
            _this29.customMonitorService.getNfEditData.nf.query = paramQuery;

            _this29.router.navigate(['/monitor/configure-log-metric-monitor']);
          });
        }
      }, {
        key: "openExitExtractedFields",
        value: function openExitExtractedFields() {
          this.showSavedExtractedField = true;
          this.getSavedExtractedFields();
        }
      }, {
        key: "openExtractFieldDialog",
        value: function openExtractFieldDialog($event, row) {
          var _this30 = this;

          var text = $($event.target.parentElement).attr("x");
          if (text == '') return;
          this.showRegex = true;
          this.showMatchingLogs = false;
          var textType;
          this.selectedText = text;
          row.response.forEach(function (element) {
            if (element.label == 'type') {
              textType = element.value.replace(/<mark>/g, "").replace(/<\/mark>/g, "");
            }

            if (element.label == 'message') {
              _this30.selectedTextLog = element.value.replace(/<mark>/g, "").replace(/<\/mark>/g, "");
            }
          });
          this.similarSourceTypeMsg = [];
          this.data.data.tableData.forEach(function (element) {
            element.response.forEach(function (ele) {
              if (ele.label == 'message') {
                _this30.similarSourceTypeMsg.push(ele.value.replace(/<mark>/g, "").replace(/<\/mark>/g, ""));
              }

              if (ele.label == 'type' && ele.value != textType) {
                _this30.similarSourceTypeMsg.pop();
              }
            });
          });
          this.extractFields = {
            selectedText: text,
            selectedTextType: textType,
            rex: this.get_rex(),
            title: '',
            type: 'logExtract',
            selectedTextMsg: this.selectedTextLog,
            startIdx: this.selectedTextStartIdx
          };
        }
      }, {
        key: "closeExtractFieldDialog",
        value: function closeExtractFieldDialog($event) {
          this.isEditExistExtractedField = false;
          this.showSelectedLogMsg = true;
        }
      }, {
        key: "createRegex",
        value: function createRegex() {
          this.regex = '';
          var str = 'a'; //including space in specialChar

          var adjacentEleValIncaseOfSpecialChar;
          var adjacentEleValIncaseOfStrNum;
          var isSimilarAdjacentVal;
          var lenOfSimialarAdjacentSpecialChar;
          var adjacentEleIdx = 1; //replace -> forwardslash

          var replace = str.replace(/a/g, "\\");
          var substr = this.selectedTextLog.substring(0, this.selectedTextStartIdx);

          for (var _i = substr.length - 1; _i >= 0; _i--) {
            if (this.determine_char_type(substr[_i]) == 'CHARACTER' || this.determine_char_type(substr[_i]) == 'DIGIT') {
              adjacentEleValIncaseOfStrNum = replace + 'w+';
            } else {
              adjacentEleIdx = _i;

              if (substr[_i] == '?' || substr[_i] == '[' || substr[_i] == ']') {
                adjacentEleValIncaseOfSpecialChar = substr[_i];
                break;
              } else {
                adjacentEleValIncaseOfSpecialChar = substr[_i];
                break;
              }
            }
          } //checking for if similar adjacent ele present in rest of the string.


          isSimilarAdjacentVal = this.selectedTextLog.substring(0, adjacentEleIdx - 1).includes(adjacentEleValIncaseOfSpecialChar);
          if (isSimilarAdjacentVal == true) lenOfSimialarAdjacentSpecialChar = this.selectedTextLog.substring(0, adjacentEleIdx - 1).split(adjacentEleValIncaseOfSpecialChar).length;
          var type = this.determine_char_type(this.selectedText[0]);
          var i = 0;
          var rex = '';
          var isUpperCase = false;

          while (i < this.selectedText.length) {
            if (type == this.determine_char_type(this.selectedText[i])) {
              if (this.selectedText[i].match(/[A-Z]/)) {
                isUpperCase = true;
              }

              i++;
            } else {
              if (type == 'CHARACTER') {
                if (this.determine_char_type(this.selectedText[i]) == 'DIGIT') {
                  while (this.determine_char_type(this.selectedText[i]) != 'SPECIAL' && this.determine_char_type(this.selectedText[i]) != 'WHITESPACE' && i < this.selectedText.length) {
                    i++;
                  }

                  rex += replace + 'w+';
                } else {
                  rex += isUpperCase == true ? replace + 'w+' : '[a-z]+';
                }

                isUpperCase = false;
              } else if (type == 'DIGIT') {
                rex += replace + 'd+';
              } else if (type == 'WHITESPACE') {
                rex += replace + 's';
              } else {
                rex += replace + this.selectedText[i - 1];
              }

              type = this.determine_char_type(this.selectedText[i]);
            }
          } //to add last matching value || selected text is of same type 


          if (type == 'CHARACTER') {
            rex += isUpperCase == true ? replace + 'w+' : '[a-z]+';
          } else if (type == 'DIGIT') {
            rex += replace + 'd+';
          } else if (type == 'WHITESPACE') {
            rex += replace + 's';
          } else if (type == 'UNDEFINE') {
            rex += '';
          } else {
            rex += replace + this.selectedText[i - 1];
          }

          if (adjacentEleValIncaseOfSpecialChar == '?' || adjacentEleValIncaseOfSpecialChar == '[' || adjacentEleValIncaseOfSpecialChar == ']' || adjacentEleValIncaseOfSpecialChar == '+') {
            adjacentEleValIncaseOfSpecialChar = replace + adjacentEleValIncaseOfSpecialChar;
          }

          if (isSimilarAdjacentVal == true) {
            //some text before selected text is not of type string or number.
            if (adjacentEleValIncaseOfStrNum == undefined) {
              this.regex = "^(?:[^" + adjacentEleValIncaseOfSpecialChar + replace + 'n]*' + adjacentEleValIncaseOfSpecialChar + '){' + lenOfSimialarAdjacentSpecialChar + '}' + '(' + rex + ')';
            } else {
              this.regex = "^(?:[^" + adjacentEleValIncaseOfSpecialChar + replace + 'n]*' + adjacentEleValIncaseOfSpecialChar + '){' + lenOfSimialarAdjacentSpecialChar + '}' + adjacentEleValIncaseOfStrNum + '(' + rex + ')';
            }
          } else {
            //when text is selected from starting
            if (adjacentEleValIncaseOfSpecialChar == undefined && adjacentEleValIncaseOfStrNum == undefined) {
              this.regex = '^(' + rex + ')';
            } //some text is present before selected text
            else if (adjacentEleValIncaseOfSpecialChar == undefined) {
              this.regex = '^' + substr + '(' + rex + ')';
            } else {
              this.regex = '^[^' + adjacentEleValIncaseOfSpecialChar + replace + 'n]*' + adjacentEleValIncaseOfSpecialChar + '(' + rex + ')';
            }
          }
        }
      }, {
        key: "determine_char_type",
        value: function determine_char_type(_char) {
          if (_char == undefined) {
            return "UNDEFINE";
          }

          if (_char.match(/[a-zA-Z]/)) {
            return "CHARACTER";
          } else if (_char.match(/\d/)) {
            return "DIGIT";
          } else if (_char.match(/\s/)) {
            return "WHITESPACE";
          } else {
            return "SPECIAL";
          }
        }
      }, {
        key: "get_rex",
        value: function get_rex() {
          this.createRegex();
          return this.regex;
        }
      }, {
        key: "onKeyPress",
        value: function onKeyPress($event) {
          var displayNamePattern = new RegExp(/[A-Za-z_]+$/);
          var title = this.extractFields.title;

          if (displayNamePattern.test($event.key)) {
            //check if two underscores are consecutive
            if (title != '' && $event.key == '_' && title.charAt(title.length - 1) == '_') {
              return false;
            }

            return true;
          } else {
            return false;
          }
        }
      }, {
        key: "getSimilarSourceTypeMessage",
        value: function getSimilarSourceTypeMessage() {
          var _this31 = this;

          this.data.data.tableData.forEach(function (element) {
            element.response.forEach(function (ele) {
              if (ele.label == 'message') {
                _this31.similarSourceTypeMsg.push(ele.value);
              }

              if (ele.label == 'type' && ele.value != _this31.extractFields.selectedTextType) {
                _this31.similarSourceTypeMsg.pop();
              }
            });
          });
        }
      }, {
        key: "previewExtractField",
        value: function previewExtractField() {
          var _this32 = this;

          var str = 'a'; //replace -> forwardslash
          // let replace = str.replace(/a/g, "\\");

          var isMatchingValuePresent;
          this.extractFields.title = this.extractFields.title.trimStart();

          if (this.similarSourceTypeMsg.length == 0) {
            this.getSimilarSourceTypeMessage();
          }

          this.showSelectedLogMsg = false;
          this.showMatchingLogs = true;
          this.similarSourceTypeMsgMatchVal = [];
          this.similarSourceTypeMsg.forEach(function (element) {
            var match = element.match(_this32.extractFields.rex);

            if (match) {
              _this32.similarSourceTypeMsgMatchVal.push(match[1]);

              isMatchingValuePresent = true;
            } else {
              _this32.similarSourceTypeMsgMatchVal.push('');
            }
          });

          if (isMatchingValuePresent != true) {
            this.similarSourceTypeMsg = [];
          }
        }
      }, {
        key: "saveExtractField",
        value: function saveExtractField() {
          var _this33 = this;

          //check field name should not start with space
          this.extractFields.title = this.extractFields.title.trimStart();

          if (this.isFieldNameEnable == true) {
            // this.isFieldNameEnable = false;
            this.savedExtractFields.forEach(function (data) {
              if (data.name == _this33.extractFields.title) {
                data.sourceData.selectedText = _this33.extractFields.selectedText;
                data.sourceData.rex = _this33.extractFields.rex;
              }
            });
          } else {
            this.nf.saveExtractedFieldName(this.extractFields).subscribe(function (state) {
              _this33.extractFields = _this33.extractFields;

              if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["ExtractFieldsLoadingState"]) {
                _this33.onExtractFieldsLoading(state);

                return;
              }

              if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["ExtractFieldsLoadedState"]) {
                _this33.onExtractFieldsLoaded(state);

                setTimeout(function () {
                  _this33.getSavedExtractedFields();
                }, 600);

                if (state.data['statusCode'] == 409) {
                  _this33.confirmationService.confirm({
                    header: 'Confirmation',
                    message: 'Are you sure you want to overwrite ' + _this33.extractFields['title'],
                    icon: 'pi pi-exclamation-triangle',
                    accept: function accept() {
                      _this33.nf.saveExistExtractedData(_this33.extractFields).subscribe(function (state) {
                        if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["ExtractFieldsLoadingState"]) {
                          _this33.onExtractFieldsLoading(state);

                          return;
                        }

                        if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["ExtractFieldsLoadedState"]) {
                          _this33.onExtractFieldsLoaded(state);

                          setTimeout(function () {
                            _this33.getSavedExtractedFields();
                          }, 1000);

                          _this33.messageService.add({
                            severity: 'success',
                            summary: 'Saved Field Successfully.',
                            detail: 'Save Field'
                          });

                          _this33.showRegex = false;
                          return;
                        }
                      });
                    },
                    reject: function reject() {
                      return;
                    }
                  });
                } else {
                  if (window['logLevel'] > 0) {
                    console.log('saved searched');
                  }

                  _this33.messageService.add({
                    severity: 'success',
                    summary: 'Saved Field Successfully.',
                    detail: 'Save Field'
                  });

                  _this33.showRegex = false;
                  return;
                }
              }
            }, function (state) {
              _this33.onExtractFieldsLoadingError(state);
            });
          }
        }
      }, {
        key: "editSavedRegularExp",
        value: function editSavedRegularExp(item) {
          var _this34 = this;

          this.isEditExistExtractedField = true;
          this.extractFields = {
            selectedText: item.selectedText,
            selectedTextType: item.selectedTextType,
            rex: item.rex,
            title: item.title,
            type: 'logExtract',
            selectedTextMsg: item.selectedTextMsg,
            startIdx: this.selectedTextStartIdx
          };
          this.showSavedExtractedField = false;
          this.showRegex = true;
          this.showMatchingLogs = false;
          this.similarSourceTypeMsg = [];
          this.data.data.tableData.forEach(function (element) {
            element.response.forEach(function (ele) {
              if (ele.label == 'message') {
                _this34.similarSourceTypeMsg.push(ele.value);
              }

              if (ele.label == 'type' && ele.value != _this34.extractFields.selectedTextType) {
                _this34.similarSourceTypeMsg.pop();
              }
            });
          });
        }
      }, {
        key: "deleteSavedExtractField",
        value: function deleteSavedExtractField(data) {
          var _this35 = this;

          this.nf.deleteSavedSearch(data).subscribe(function (state) {
            if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["ExtractFieldsLoadingState"]) {
              _this35.onExtractFieldsLoading(state);

              return;
            }

            if (state instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["ExtractFieldsLoadedState"]) {
              _this35.messageService.add({
                severity: 'success',
                summary: 'Field Delete Successfully.',
                detail: 'Delete Search'
              });

              _this35.savedExtractFields = state.data.savedObject;

              _this35.getSavedExtractFieldsList();

              return;
            }
          }, function (state) {
            _this35.onExtractFieldsLoadingError(state);
          });
        }
      }, {
        key: "getSavedExtractFieldsList",
        value: function getSavedExtractFieldsList() {
          var _this36 = this;

          this.savedExtractFieldsList = [];

          if (Array.isArray(this.savedExtractFields)) {
            this.savedExtractFields.forEach(function (element) {
              _this36.savedExtractFieldsList.push(element.sourceData);
            });
          } else this.messageService.add({
            severity: "error",
            summary: "Error",
            detail: this.savedExtractFields.message
          });
        }
      }, {
        key: "getSavedExtractedFields",
        value: function getSavedExtractedFields() {
          var _this37 = this;

          this.nf.getSavedSearch().subscribe(function (state) {
            _this37.savedExtractFields = state;

            _this37.getSavedExtractFieldsList();
          });
        }
      }, {
        key: "onExtractFieldsLoading",
        value: function onExtractFieldsLoading(state) {
          var me = this;
        }
      }, {
        key: "onExtractFieldsLoaded",
        value: function onExtractFieldsLoaded(state) {
          var me = this;
        }
      }, {
        key: "onExtractFieldsLoadingError",
        value: function onExtractFieldsLoadingError(state) {
          var _a, _b;

          var me = this;
          me.messageService.add({
            severity: 'error',
            summary: (_b = (_a = state === null || state === void 0 ? void 0 : state.data) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.text,
            sticky: false,
            life: 10000
          });
        }
      }, {
        key: "copyTextFilter",
        value: function copyTextFilter(event) {
          if (window['logLevel'] > 0) {
            console.log(event[0] + ':' + event[1]);
          }

          this.chipsValues.push({
            filterValue: event[0] + ':' + event[1],
            chipType: event[2]
          });
        }
      }, {
        key: "onRemoveTag",
        value: function onRemoveTag(event) {
          var eventval = event.value.filterValue.split(':');
          this.filtervalue = eventval[0]; //if same field name has multiple values than 'i' value will be same & for different fields 'i' value will change example parser_tags.

          for (var i = 0; i < this.plus_arr.length;) {
            if (Object.keys(this.plus_arr[i].match_phrase)[0] == eventval[0] && event.value.filterValue.substring(event.value.filterValue.indexOf(':') + 1).includes(this.plus_arr[i].match_phrase[eventval[0]].query)) {
              this.plus_arr.splice(i, 1);
              this.nf.plus_arrChanged.emit(eventval);
              i = i;
            } else {
              i++;
            }
          }

          for (var _i2 = 0; _i2 < this.minus_arr.length;) {
            //changes regarding bug 146045
            if (Object.keys(this.minus_arr[_i2].match_phrase)[0] == eventval[0] && event.value.filterValue.substring(event.value.filterValue.indexOf(':') + 1).includes(this.minus_arr[_i2].match_phrase[eventval[0]].query)) {
              this.minus_arr.splice(_i2, 1);
              _i2 = _i2;
            } else {
              _i2++;
            }
          }

          for (var _i3 = 0; _i3 < this.exist_arr.length; _i3++) {
            if (Object.values(this.exist_arr[_i3].exists)[0] == eventval[1]) {
              this.exist_arr.splice(_i3, 1);
              this.nf.exist_arrChanged.emit(eventval);
            }
          }

          this.gte = undefined;
          this.lte = undefined;
          this.fetchData();
        }
      }, {
        key: "callDocCount",
        value: function callDocCount(row) {
          var _this38 = this;

          var key;
          var queryValue;
          row.response.forEach(function (element, index) {
            if (element.label == 'log_key') {
              key = element.value.replace(/<mark>/g, "").replace(/<\/mark>/g, "");
            }
          });
          var indexValue = this.query.substring(this.query.indexOf('=') + 1, this.query.indexOf('query')).trim();
          queryValue = this.query.substring(this.query.indexOf('query=') + 6, this.query.indexOf('|dedup log_key')); //query already includes same log_key.

          if (queryValue.includes('|where log_key==' + '"' + key + '"')) {
            var idx = queryValue.indexOf('|where log_key==' + '"' + key + '"');
            var preQuery = queryValue.substring(0, idx);
            var restOfStrWithoutLok_key = queryValue.substring(idx + 17);
            var postQuery = restOfStrWithoutLok_key.substring(key.length + 1);
            queryValue = preQuery + postQuery;
          }

          this.query = 'index=' + indexValue + ' query=' + queryValue + '|where log_key==' + '"' + key + '"';

          if ((document.getElementById('searchQuery')['value'].includes('index=') && document.getElementById('searchQuery')['value'].includes('query=')) == true) {
            document.getElementById('searchQuery')['value'] = this.query;
          } else {
            document.getElementById('searchQuery')['value'] = queryValue + '|where log_key==' + '"' + key + '"';
          }

          this.isCacheButton = true; //it helps us to differentiate between two follow log stream method i.e getAllInstance & getSimilerData

          this.isInstanceFollowLogStream = true;
          this.isDedupChecked = false;
          this.fetchData();
          this.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];

          if (!this.data.headers[0].cols.some(function (ele) {
            return ele.label == '';
          })) {
            this.addIconColumn();
          }

          this.clearVal = false;
          this.data.headers[0].cols.forEach(function (element, index) {
            if (element.label == 'Count') {
              _this38.data.headers[0].cols.splice(index, 1);
            }
          }); //directing to first page of pagination

          this.first = 0;
          this.configService.storeData(this.cacheLogData, this.cacheAggData, this.cacheSearchbarQuery, this.cacheFieldsData, this.sortValue, this.similerMessageVal, this.similerLogHiglightVal, this.cacheSearchBarVisibleQuery, this.cacheXaxisData);
        }
      }, {
        key: "groupSimilerLogs",
        value: function groupSimilerLogs() {
          this.isDedupChecked = !this.isDedupChecked;
          this.addDedupQuery();
        }
      }, {
        key: "addDedupQuery",
        value: function addDedupQuery() {
          var _this39 = this;

          if (this.isDedupChecked) {
            this.fetchData();
            this.clearVal = false;
          }

          if (this.isDedupChecked == false) {
            //removing count column from log_information table
            var isLogInfoPresent;
            this.data.headers[0].cols.forEach(function (ele, idx) {
              if (ele.label == 'Count') {
                _this39.data.headers[0].cols.splice(idx, 1);
              }

              if (ele.label == 'Log Information') {
                isLogInfoPresent = true;
              }
            });

            if (isLogInfoPresent == true) {
              this.isCustomTable = false;
              this.isCreateTable = false;
            } //removing |dedup log_key from query


            this.query = this.query.substring(0, this.query.indexOf('|dedup log_key'));
            this.fetchData();
            this.clearVal = false;
          }
        }
      }, {
        key: "dedupQuery",
        value: function dedupQuery() {
          var colLength = this.data.headers[0].cols.length;
          var queryDedup = {
            label: 'Count',
            valueField: 'doc_count',
            classes: 'docClass',
            width: '15%',
            selected: true
          };

          if (this.data.headers[0].cols.some(function (ele) {
            return ele.label == '';
          })) {
            this.data.headers[0].cols.splice(colLength - 1, 0, queryDedup);
          } else {
            this.data.headers[0].cols.splice(colLength, 0, queryDedup);
          }
        }
      }, {
        key: "addIconColumn",
        value: function addIconColumn() {
          var colLength = this.data.headers[0].cols.length;
          var addIconCol = {
            label: '',
            valueField: 'icon',
            classes: 'ddrIconClass',
            iconField: true
          };
          this.data.headers[0].cols.splice(colLength, 0, addIconCol);
        }
      }, {
        key: "cacheCall",
        value: function cacheCall() {
          var _this40 = this;

          this.configService.getConfigs().subscribe(function (data) {
            _this40.data.data.tableData = data.tableData;

            _this40.dedupQuery();

            _this40.chartXaxisData = data.XaxisData;
            _this40.chartYaxisData = data.chartData.data;
            _this40.tabledata = data.chartData.tabledata;
            _this40.stats = data.chartData.stats;
            _this40.hitsValue = data.chartData.stats[2].count;
            _this40.sortoptionsvalue = data.sortVal;
            document.getElementById('searchQuery')['value'] = data.cacheQueryValue;
            _this40.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];
            _this40.query = data.queryValue;
            _this40.previousQuery = _this40.query;
            _this40.fieldsdata = data.fieldsTable;
            _this40.similerMessage = data.similerMessageCacheVal != null ? data.similerMessageCacheVal : '';
            _this40.similerLogHiglight = data.similerLogHiglightCacheVal == true ? true : false;
          });

          if (this.requestUUID != null) {
            this.cancelPreviousQuery();
          } //expanded table will be collapsed


          this.expandedRows = {};
          this.data.data.tableData.forEach(function (element, rowIndex) {
            _this40.selectRow[element.no] = 0;
          });
          var fieldsDataKey = [];
          this.fieldsdata.forEach(function (element) {
            var isElement;
            fieldsDataKey.push(element.name);

            if (_this40.data.headers[0].cols.some(function (ele) {
              return ele.label == element.name && element.isSelected == true;
            })) {
              element.isSelected = true;
              isElement = true;
            } else {
              isElement = false;
            }

            _this40.data.headers[0].cols.some(function (ele, index) {
              if (ele.label == element.name && element.isSelected == false) _this40.data.headers[0].cols.splice(index, 1);
            });

            if (element.isSelected == true && !isElement) {
              element.isSelected = false;
            }
          });
          this.data.headers[0].cols.forEach(function (el, idx) {
            if (el.label != 'Time' && el.label != 'Log Information' && el.label != '' && el.label != 'Count' && el.label != 'Diff(ms)' && el.label != 'Elapsed(ms)') {
              if (fieldsDataKey.indexOf(el.label) == -1) {
                _this40.data.headers[0].cols.splice(idx, 1);
              }
            }
          });
          var isDiffColumn;
          var isElapsedColumn;
          isDiffColumn = this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Diff(ms)';
          }) == true ? true : false;
          isElapsedColumn = this.data.headers[0].cols.some(function (ele) {
            return ele.label == 'Elapsed(ms)';
          }) == true ? true : false;

          if (this.fieldsdata.every(function (ele) {
            return ele.isSelected == false;
          })) {
            if (!this.data.headers[0].cols.some(function (element) {
              return element.label == 'Log Information';
            })) {
              this.isCustomTable = false;
              this.isCreateTable = false;
              var respCol = {
                label: 'Log Information',
                valueField: 'keyword',
                classes: 'text-left',
                badgeField: true,
                width: '70%'
              };

              if (isDiffColumn == true && isElapsedColumn == true) {
                this.data.headers[0].cols.splice(3, 0, respCol);
              }

              if (isDiffColumn == true && isElapsedColumn == false || isElapsedColumn == true && isDiffColumn == false) {
                this.data.headers[0].cols.splice(2, 0, respCol);
              }

              if (isDiffColumn == false && isElapsedColumn == false) {
                this.data.headers[0].cols.splice(1, 0, respCol);
              }
            }
          }

          if (!this.fieldsdata.some(function (ele) {
            return ele.name == 'fp';
          })) {
            this.data.headers[0].cols.some(function (ele, index) {
              if (ele.label == '') {
                _this40.data.headers[0].cols.splice(index, 1);
              }
            });
          }

          if (this.query.includes('|dedup log_key')) {
            this.isDedupChecked = true;
          } else {
            this.isDedupChecked = false;
          }

          this.showCacheButton = false;
          this.showSimilarDataFollowLogStream = true;
          this.isWhereLog_key = false;

          if (!this.data.headers[0].cols.some(function (ele) {
            return ele.label == '';
          })) {
            this.addIconColumn();
          }
        }
      }, {
        key: "getAllInstance",
        value: function getAllInstance(row) {
          var _this41 = this;

          this.update_gte_lte_with_logstream = true;
          var index = this.query.substring(this.query.indexOf('=') + 1, this.query.indexOf('query')).trim();
          var queryValue;

          if (this.query.includes("|where")) {
            queryValue = this.query.substring(this.query.indexOf("query=") + 6, this.query.indexOf('|where')).startsWith("*") ? this.query.substring(this.query.indexOf("query=") + 7, this.query.indexOf('|where')) : this.query.substring(this.query.indexOf("query=") + 6, this.query.indexOf('|where'));
          } else {
            queryValue = this.query.substring(this.query.indexOf("query=") + 6).startsWith("*") ? this.query.substring(this.query.indexOf('query=') + 7) : this.query.substring(this.query.indexOf('query=') + 6);
          }

          row.response.forEach(function (element, index) {
            if (element.label == 'log_stream') {
              if (element.value.includes("mark")) {
                _this41.logStreamVal = element.value.replace(/<mark>/g, "").replace(/<\/mark>/g, "");
              } else {
                _this41.logStreamVal = element.value;
              }
            }

            if (element.label == 'message') {
              _this41.similerMessage = element.value;
            }
          }); //log stream already present,then remove it and update with new log stream value

          if (queryValue.startsWith('log_stream:')) {
            queryValue = queryValue.substring(queryValue.indexOf(this.logStreamVal) + this.logStreamVal.length + 1);
          }

          if (this.isFromDDR == true && queryValue.startsWith(this.ddrQueryValue) || queryValue != '' && queryValue.startsWith(' AND ') == false && queryValue.startsWith('|') == false) {
            queryValue = ' AND ' + queryValue;
          }

          var timeStamp = this.sessionService.convertFormattedStringIntoTimestamp(row.Time, 'YYYY-MM-DD “T” hh:mm:ss.SSSZ');
          this.query = 'index=' + index + ' query=log_stream:' + '"' + this.logStreamVal + '"' + queryValue;

          if ((document.getElementById('searchQuery')['value'].includes('index=') && document.getElementById('searchQuery')['value'].includes('query=')) == true) {
            document.getElementById('searchQuery')['value'] = this.query;
          } else {
            document.getElementById('searchQuery')['value'] = (document.getElementById('searchQuery')['value'].startsWith('*') == false && queryValue.startsWith('*') == true) == true ? 'log_stream:' + '"' + this.logStreamVal + '"' + queryValue.substring(1) : 'log_stream:' + '"' + this.logStreamVal + '"' + queryValue;
          }

          this.gte = timeStamp - this.logstreamWindow;
          this.lte = timeStamp + this.logstreamWindow;
          this.isCacheButton = true;
          this.isDedupChecked = false;
          this.fetchData();
          this.searchbarVisibleQuery = document.getElementById('searchQuery')['value'];

          if (!this.fieldsdata.some(function (ele) {
            return ele.name == 'fp';
          })) {
            this.data.headers[0].cols.some(function (ele, index) {
              if (ele.label == '') {
                _this41.data.headers[0].cols.splice(index, 1);
              }
            });
          } //directing the pagination to first page


          this.first = 0;
          this.clearVal = false;
          this.similerLogHiglight = true; //checking for icon column

          if (!this.data.headers[0].cols.some(function (ele) {
            return ele.label == '';
          })) {
            this.addIconColumn();
          }

          this.isInstanceFollowLogStream = true;
        }
      }, {
        key: "openSequence",
        value: function openSequence() {
          var _this42 = this;

          var query_string = this.query.substr(this.query.indexOf('query=') + 6, this.query.length);

          if (window['logLevel'] > 0) {
            console.log(query_string);
          }

          var indexPattern = this.query.split(' ')[0].split('=')[1];
          var convertedTimeStamp = this.convertGteLteInToTimestamp(this.gte, this.lte);
          var gteTime = convertedTimeStamp.gte;
          var lteTime = convertedTimeStamp.lte;
          var payload = {
            requestType: 'getSequenceData',
            gte: gteTime,
            lte: lteTime,
            indexPattern: indexPattern,
            query: query_string,
            timeZone: sessionStorage.getItem('_nvtimezone')
          };
          this.nf.getSequenceDiagramData(payload).subscribe(function (data) {
            if (data instanceof _service_logstab_state__WEBPACK_IMPORTED_MODULE_9__["LogsLoadedState"]) {
              _this42.nf.sequenceData = [];
              var seqObj = data.data;

              _this42.nf.sequenceData.push(seqObj);

              if (window['logLevel'] > 0) {
                console.log(_this42.nf.sequenceData);
              }

              _this42.showSequence = true;
            }

            (function (error) {
              return console.log('errorData!', error);
            });

            return;
          });
        }
      }, {
        key: "exception_data",
        value: function exception_data(val) {
          if (val.processedCount != undefined && val.totalCount != undefined) {
            this.processedCount = val === null || val === void 0 ? void 0 : val.processedCount;
            this.totalCount = val === null || val === void 0 ? void 0 : val.totalCount;
          }
        }
      }, {
        key: "exception_hitsvalue",
        value: function exception_hitsvalue(event) {
          this.hitsValue = event === null || event === void 0 ? void 0 : event.data;
        }
      }, {
        key: "exceptionTableResponse",
        value: function exceptionTableResponse(event) {
          var _a, _b, _c, _d, _e, _f, _g, _h;

          if ((_a = event === null || event === void 0 ? void 0 : event.data[0]) === null || _a === void 0 ? void 0 : _a.tableData) {
            this.data.data = event === null || event === void 0 ? void 0 : event.data[0];
          }

          if ((_b = event === null || event === void 0 ? void 0 : event.data[0]) === null || _b === void 0 ? void 0 : _b.statsData) {
            this.stats = (_c = event === null || event === void 0 ? void 0 : event.data[0]) === null || _c === void 0 ? void 0 : _c.statsData;
          }

          if (((_d = event === null || event === void 0 ? void 0 : event.data[0]) === null || _d === void 0 ? void 0 : _d.streamStatistics) && ((_f = (_e = event === null || event === void 0 ? void 0 : event.data[0]) === null || _e === void 0 ? void 0 : _e.streamStatistics) === null || _f === void 0 ? void 0 : _f.matchedCount) > 0) {
            this.hitsValue = (_h = (_g = event === null || event === void 0 ? void 0 : event.data[0]) === null || _g === void 0 ? void 0 : _g.streamStatistics) === null || _h === void 0 ? void 0 : _h.matchedCount;
          }
        }
      }, {
        key: "progressBarException",
        value: function progressBarException(val) {
          this.showProgressBar = val === null || val === void 0 ? void 0 : val.showProgressBar;
          this.displayProcessDoc = val === null || val === void 0 ? void 0 : val.showProgressBar;
        }
      }, {
        key: "cancel_exception_req",
        value: function cancel_exception_req(val) {
          this.onClickCancel = val === null || val === void 0 ? void 0 : val.cancelReq;
        }
      }, {
        key: "disable_Cancel_Button",
        value: function disable_Cancel_Button(val) {
          this.isCancelButtonDisable = val === null || val === void 0 ? void 0 : val.cancelIcon;
        }
      }, {
        key: "disable_clear_search_button",
        value: function disable_clear_search_button(val) {
          this.searchVal = val === null || val === void 0 ? void 0 : val.searchClearIcon;
        } //adding tab event

      }, {
        key: "tabclick",
        value: function tabclick(event) {
          if (event.index == 0) {
            this.isCancelButtonDisable = true;

            if (document.getElementById('searchQuery')['value'] != '') {
              this.query = document.getElementById('searchQuery')['value'].trimStart();
              this.isDedupChecked = false;
            }

            this.fieldExpandedDiv = true;
            this.switchTab = 'logs';
            this.fetchData();
          } else if (event.index == 1) {
            this.indexpattern = this.query.split(" ")[0].split("=")[1];
            this.query = this.query.substr(this.query.indexOf("query=") + 6, this.query.length);

            if (this.requestUUID != null) {
              this.cancelPreviousQuery();
            }

            this.fieldExpandedDiv = false;
            this.switchTab = 'exception';
            this.exceptionTableLoading = true;
            this.exceptionGteValue = this.tb.getValue().time.frameStart.value;
            this.exceptionLteValue = this.tb.getValue().time.frameEnd.value;
          }

          this.closeItem();
        }
      }]);
    }();

    LogstabComponent.ctorParameters = function () {
      return [{
        type: _angular_core__WEBPACK_IMPORTED_MODULE_1__["ChangeDetectorRef"]
      }, {
        type: _tools_actions_ddr_data_model_service__WEBPACK_IMPORTED_MODULE_15__["DdrDataModelService"]
      }, {
        type: src_app_core_breadcrumb_breadcrumb_service__WEBPACK_IMPORTED_MODULE_16__["BreadcrumbService"]
      }, {
        type: _angular_router__WEBPACK_IMPORTED_MODULE_14__["ActivatedRoute"]
      }, {
        type: src_app_shared_scheduler_scheduler_service__WEBPACK_IMPORTED_MODULE_12__["SchedulerService"]
      }, {
        type: src_app_shared_cav_toast_service_cav_message_service__WEBPACK_IMPORTED_MODULE_30__["CavMessageService"]
      }, {
        type: _service_nf_logs_service__WEBPACK_IMPORTED_MODULE_8__["NfLogsService"]
      }, {
        type: _angular_router__WEBPACK_IMPORTED_MODULE_14__["Router"]
      }, {
        type: src_app_shared_time_bar_service_time_bar_service__WEBPACK_IMPORTED_MODULE_7__["TimebarService"]
      }, {
        type: _query_settings_service_query_settings_service__WEBPACK_IMPORTED_MODULE_10__["QuerySettingsService"]
      }, {
        type: src_app_core_session_session_service__WEBPACK_IMPORTED_MODULE_18__["SessionService"]
      }, {
        type: _log_integration_service_log_integration_service__WEBPACK_IMPORTED_MODULE_19__["Logintegrationservice"]
      }, {
        type: _service_config_service__WEBPACK_IMPORTED_MODULE_20__["ConfigService"]
      }, {
        type: _my_library_search_service_search_service__WEBPACK_IMPORTED_MODULE_21__["SearchService"]
      }, {
        type: _monitor_up_down_status_configure_monitors_add_custom_monitor_services_custom_monitor_service__WEBPACK_IMPORTED_MODULE_23__["CustomMonitorService"]
      }, {
        type: _monitor_up_down_status_service_monitorupdownstatus_service__WEBPACK_IMPORTED_MODULE_25__["MonitorupdownstatusService"]
      }, {
        type: _nf_add_remote_cluster_nf_remote_cluster_service_nf_remote_cluster_service__WEBPACK_IMPORTED_MODULE_27__["NfRemoteClusterService"]
      }, {
        type: primeng__WEBPACK_IMPORTED_MODULE_4__["ConfirmationService"]
      }, {
        type: _angular_core__WEBPACK_IMPORTED_MODULE_1__["Renderer2"]
      }, {
        type: src_app_shared_pipes_pipe_service__WEBPACK_IMPORTED_MODULE_32__["PipeService"]
      }, {
        type: undefined,
        decorators: [{
          type: _angular_core__WEBPACK_IMPORTED_MODULE_1__["Optional"]
        }, {
          type: _angular_core__WEBPACK_IMPORTED_MODULE_1__["Inject"],
          args: [src_app_pages_tools_admin_access_control_services_access_control_model__WEBPACK_IMPORTED_MODULE_33__["ACL_PROPS"]]
        }]
      }];
    };

    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Output"])()], LogstabComponent.prototype, "rowClick", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["ViewChild"])('saveSearchData', {
      read: src_app_shared_save_dialog_save_dialog_component__WEBPACK_IMPORTED_MODULE_5__["SaveDialogComponent"]
    })], LogstabComponent.prototype, "saveSearchData", void 0);
    Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["HostListener"])('window:beforeunload', ['$event'])], LogstabComponent.prototype, "beforeUnloadHandler", null);
    LogstabComponent = Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Component"])({
      selector: 'app-logstab',
      template: Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__importDefault"])(__webpack_require__(
      /*! raw-loader!./logstab.component.html */
      "./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/logstab.component.html"))["default"],
      encapsulation: _angular_core__WEBPACK_IMPORTED_MODULE_1__["ViewEncapsulation"].None,
      providers: [[{
        provide: src_app_pages_tools_admin_access_control_services_access_control_model__WEBPACK_IMPORTED_MODULE_33__["ACL_PROPS"],
        useValue: {
          feature: _tools_admin_access_control_management_constants_cav_acl_features_constants__WEBPACK_IMPORTED_MODULE_34__["CAV_FEATURES"].LOGS.NAME,
          subFeature: _tools_admin_access_control_management_constants_cav_acl_features_constants__WEBPACK_IMPORTED_MODULE_34__["CAV_FEATURES"].LOGS.SUB_FEATURES.QUERY
        }
      }]],
      styles: [Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__importDefault"])(__webpack_require__(
      /*! ./logstab.component.scss */
      "./src/app/pages/home/logstab/logstab.component.scss"))["default"]]
    }), Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__param"])(20, Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Optional"])()), Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__param"])(20, Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Inject"])(src_app_pages_tools_admin_access_control_services_access_control_model__WEBPACK_IMPORTED_MODULE_33__["ACL_PROPS"]))], LogstabComponent);
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/logstab.module.ts":
  /*!******************************************************!*\
    !*** ./src/app/pages/home/logstab/logstab.module.ts ***!
    \******************************************************/

  /*! exports provided: LogstabModule */

  /***/
  function _src_app_pages_home_logstab_logstabModuleTs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "LogstabModule", function () {
      return LogstabModule;
    });
    /* harmony import */


    var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! tslib */
    "./node_modules/tslib/tslib.es6.js");
    /* harmony import */


    var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
    /*! @angular/core */
    "./node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js");
    /* harmony import */


    var _angular_common__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(
    /*! @angular/common */
    "./node_modules/@angular/common/__ivy_ngcc__/fesm2015/common.js");
    /* harmony import */


    var _logstab_component__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(
    /*! ./logstab.component */
    "./src/app/pages/home/logstab/logstab.component.ts");
    /* harmony import */


    var _angular_router__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(
    /*! @angular/router */
    "./node_modules/@angular/router/__ivy_ngcc__/fesm2015/router.js");
    /* harmony import */


    var primeng__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(
    /*! primeng */
    "./node_modules/primeng/__ivy_ngcc__/fesm2015/primeng.js");
    /* harmony import */


    var _angular_forms__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(
    /*! @angular/forms */
    "./node_modules/@angular/forms/__ivy_ngcc__/fesm2015/forms.js");
    /* harmony import */


    var _log_integration_log_integration_module__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(
    /*! ./log-integration/log-integration.module */
    "./src/app/pages/home/logstab/log-integration/log-integration.module.ts");
    /* harmony import */


    var src_app_shared_save_dialog_save_dialog_module__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(
    /*! src/app/shared/save-dialog/save-dialog.module */
    "./src/app/shared/save-dialog/save-dialog.module.ts");
    /* harmony import */


    var src_app_shared_visualization_visual_chart_visual_chart_module__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(
    /*! src/app/shared/visualization/visual-chart/visual-chart.module */
    "./src/app/shared/visualization/visual-chart/visual-chart.module.ts");
    /* harmony import */


    var src_app_shared_visualization_visual_table_visual_table_module__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(
    /*! src/app/shared/visualization/visual-table/visual-table.module */
    "./src/app/shared/visualization/visual-table/visual-table.module.ts");
    /* harmony import */


    var src_app_shared_visualization_visual_statistics_visual_statistics_module__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(
    /*! src/app/shared/visualization/visual-statistics/visual-statistics.module */
    "./src/app/shared/visualization/visual-statistics/visual-statistics.module.ts");
    /* harmony import */


    var src_app_shared_visualization_visual_request_visual_request_module__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(
    /*! src/app/shared/visualization/visual-request/visual-request.module */
    "./src/app/shared/visualization/visual-request/visual-request.module.ts");
    /* harmony import */


    var src_app_shared_visualization_visual_response_visual_response_module__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(
    /*! src/app/shared/visualization/visual-response/visual-response.module */
    "./src/app/shared/visualization/visual-response/visual-response.module.ts");
    /* harmony import */


    var src_app_shared_search_sidebar_commonfilter_commonfilter_module__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(
    /*! src/app/shared/search-sidebar/commonfilter/commonfilter.module */
    "./src/app/shared/search-sidebar/commonfilter/commonfilter.module.ts");
    /* harmony import */


    var _log_details_log_details_component__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(
    /*! ./log-details/log-details.component */
    "./src/app/pages/home/logstab/log-details/log-details.component.ts");
    /* harmony import */


    var _log_details_log_details_module__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(
    /*! ./log-details/log-details.module */
    "./src/app/pages/home/logstab/log-details/log-details.module.ts");
    /* harmony import */


    var _no_result_found_no_result_found_component__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(
    /*! ./no-result-found/no-result-found.component */
    "./src/app/pages/home/logstab/no-result-found/no-result-found.component.ts");
    /* harmony import */


    var _angular_material_menu__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(
    /*! @angular/material/menu */
    "./node_modules/@angular/material/__ivy_ngcc__/fesm2015/menu.js");
    /* harmony import */


    var _angular_material_button__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(
    /*! @angular/material/button */
    "./node_modules/@angular/material/__ivy_ngcc__/fesm2015/button.js");
    /* harmony import */


    var _angular_material_checkbox__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(
    /*! @angular/material/checkbox */
    "./node_modules/@angular/material/__ivy_ngcc__/fesm2015/checkbox.js");
    /* harmony import */


    var _log_sequence_diagram_log_sequence_diagram_component__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(
    /*! ./log-sequence-diagram/log-sequence-diagram.component */
    "./src/app/pages/home/logstab/log-sequence-diagram/log-sequence-diagram.component.ts");
    /* harmony import */


    var src_app_shared_help_help_module__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(
    /*! src/app/shared/help/help.module */
    "./src/app/shared/help/help.module.ts");
    /* harmony import */


    var src_app_shared_cav_table_cav_table_module__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(
    /*! src/app/shared/cav-table/cav-table.module */
    "./src/app/shared/cav-table/cav-table.module.ts");
    /* harmony import */


    var _log_exceptions_log_exceptions_module__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(
    /*! ./log-exceptions/log-exceptions.module */
    "./src/app/pages/home/logstab/log-exceptions/log-exceptions.module.ts");
    /* harmony import */


    var src_app_shared_cav_loader_cav_loader_module__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(
    /*! src/app/shared/cav-loader/cav-loader.module */
    "./src/app/shared/cav-loader/cav-loader.module.ts");

    var imports = [_angular_common__WEBPACK_IMPORTED_MODULE_2__["CommonModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["InputTextModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["TooltipModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["AutoCompleteModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["ButtonModule"], _angular_forms__WEBPACK_IMPORTED_MODULE_6__["FormsModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["CardModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["DropdownModule"], _log_integration_log_integration_module__WEBPACK_IMPORTED_MODULE_7__["LogIntegrationModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["ChipsModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["TabMenuModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["MenuModule"], src_app_shared_save_dialog_save_dialog_module__WEBPACK_IMPORTED_MODULE_8__["SaveDialogModule"], src_app_shared_visualization_visual_chart_visual_chart_module__WEBPACK_IMPORTED_MODULE_9__["VisualChartModule"], src_app_shared_visualization_visual_statistics_visual_statistics_module__WEBPACK_IMPORTED_MODULE_11__["VisualStatisticsModule"], src_app_shared_visualization_visual_table_visual_table_module__WEBPACK_IMPORTED_MODULE_10__["VisualTableModule"], src_app_shared_visualization_visual_request_visual_request_module__WEBPACK_IMPORTED_MODULE_12__["VisualRequestModule"], src_app_shared_visualization_visual_response_visual_response_module__WEBPACK_IMPORTED_MODULE_13__["VisualResponseModule"], src_app_shared_search_sidebar_commonfilter_commonfilter_module__WEBPACK_IMPORTED_MODULE_14__["CommonfilterModule"], src_app_shared_save_dialog_save_dialog_module__WEBPACK_IMPORTED_MODULE_8__["SaveDialogModule"], _log_details_log_details_module__WEBPACK_IMPORTED_MODULE_16__["LogDetailsModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["TableModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["OverlayPanelModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["BreadcrumbModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["DialogModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["OrderListModule"], _angular_material_menu__WEBPACK_IMPORTED_MODULE_18__["MatMenuModule"], _angular_material_button__WEBPACK_IMPORTED_MODULE_19__["MatButtonModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["CheckboxModule"], _angular_material_checkbox__WEBPACK_IMPORTED_MODULE_20__["MatCheckboxModule"], src_app_shared_help_help_module__WEBPACK_IMPORTED_MODULE_22__["HelpModule"], src_app_shared_cav_table_cav_table_module__WEBPACK_IMPORTED_MODULE_23__["CavTableModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["ProgressBarModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["SidebarModule"], _log_exceptions_log_exceptions_module__WEBPACK_IMPORTED_MODULE_24__["LogExceptionsModule"], primeng__WEBPACK_IMPORTED_MODULE_5__["TabViewModule"], src_app_shared_cav_loader_cav_loader_module__WEBPACK_IMPORTED_MODULE_25__["CavLoaderModule"]];
    var components = [_logstab_component__WEBPACK_IMPORTED_MODULE_3__["LogstabComponent"]];
    var routes = [{
      path: '',
      component: _logstab_component__WEBPACK_IMPORTED_MODULE_3__["LogstabComponent"],
      children: [{
        path: 'log-details',
        loadChildren: function loadChildren() {
          return Promise.resolve().then(__webpack_require__.bind(null,
          /*! ./log-details/log-details.module */
          "./src/app/pages/home/logstab/log-details/log-details.module.ts")).then(function (m) {
            return m.LogDetailsModule;
          });
        },
        component: _log_details_log_details_component__WEBPACK_IMPORTED_MODULE_15__["LogDetailsComponent"]
      }]
    }];

    var LogstabModule = /*#__PURE__*/_createClass(function LogstabModule() {
      _classCallCheck(this, LogstabModule);
    });

    LogstabModule = Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["NgModule"])({
      declarations: [components, _no_result_found_no_result_found_component__WEBPACK_IMPORTED_MODULE_17__["NoResultFoundComponent"], _log_sequence_diagram_log_sequence_diagram_component__WEBPACK_IMPORTED_MODULE_21__["LogSequenceDiagramComponent"]],
      imports: [imports, _angular_router__WEBPACK_IMPORTED_MODULE_4__["RouterModule"].forChild(routes)],
      exports: [_angular_router__WEBPACK_IMPORTED_MODULE_4__["RouterModule"]]
    })], LogstabModule);
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/no-result-found/no-result-found.component.scss":
  /*!***********************************************************************************!*\
    !*** ./src/app/pages/home/logstab/no-result-found/no-result-found.component.scss ***!
    \***********************************************************************************/

  /*! exports provided: default */

  /***/
  function _src_app_pages_home_logstab_noResultFound_noResultFoundComponentScss(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony default export */


    __webpack_exports__["default"] = "h1 {\n  font-family: arial;\n  font-weight: normal;\n  font-size: 25px;\n}\n\n#msg1 {\n  font-family: arial;\n  color: #666;\n  font-size: 13px;\n}\n\n#msg2 {\n  font-family: arial;\n  color: #666;\n  font-size: 13px;\n  line-height: 180%;\n}\n\nh2 {\n  font-family: arial;\n  font-weight: normal;\n  font-size: 18px;\n}\n\nh3 {\n  font-family: arial;\n  font-weight: normal;\n  font-size: 18px;\n}\n\ninput[type=text] {\n  padding: 10px;\n  background-color: #F2F4F4;\n  border: 1px solid #909497;\n  width: 95%;\n  border-radius: 3px;\n}\n\n#time-picker-btn {\n  background-color: #F39C12;\n  padding: 6px;\n  color: #fff;\n  font-family: arial;\n  font-size: 12px;\n  border: 1px solid #F39C12;\n  text-decoration: none;\n  border-radius: 4px;\n  cursor: pointer;\n}\n\n#time-picker-btn:hover {\n  color: #333;\n}";
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/no-result-found/no-result-found.component.ts":
  /*!*********************************************************************************!*\
    !*** ./src/app/pages/home/logstab/no-result-found/no-result-found.component.ts ***!
    \*********************************************************************************/

  /*! exports provided: NoResultFoundComponent */

  /***/
  function _src_app_pages_home_logstab_noResultFound_noResultFoundComponentTs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "NoResultFoundComponent", function () {
      return NoResultFoundComponent;
    });
    /* harmony import */


    var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! tslib */
    "./node_modules/tslib/tslib.es6.js");
    /* harmony import */


    var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
    /*! @angular/core */
    "./node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js");

    var NoResultFoundComponent = /*#__PURE__*/function () {
      function NoResultFoundComponent() {
        _classCallCheck(this, NoResultFoundComponent);
      }

      return _createClass(NoResultFoundComponent, [{
        key: "ngOnInit",
        value: function ngOnInit() {}
      }]);
    }();

    NoResultFoundComponent = Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Component"])({
      selector: 'app-no-result-found',
      template: Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__importDefault"])(__webpack_require__(
      /*! raw-loader!./no-result-found.component.html */
      "./node_modules/raw-loader/dist/cjs.js!./src/app/pages/home/logstab/no-result-found/no-result-found.component.html"))["default"],
      styles: [Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__importDefault"])(__webpack_require__(
      /*! ./no-result-found.component.scss */
      "./src/app/pages/home/logstab/no-result-found/no-result-found.component.scss"))["default"]]
    })], NoResultFoundComponent);
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/service/config.service.ts":
  /*!**************************************************************!*\
    !*** ./src/app/pages/home/logstab/service/config.service.ts ***!
    \**************************************************************/

  /*! exports provided: ConfigService */

  /***/
  function _src_app_pages_home_logstab_service_configServiceTs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "ConfigService", function () {
      return ConfigService;
    });
    /* harmony import */


    var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
    /*! tslib */
    "./node_modules/tslib/tslib.es6.js");
    /* harmony import */


    var _angular_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(
    /*! @angular/core */
    "./node_modules/@angular/core/__ivy_ngcc__/fesm2015/core.js");
    /* harmony import */


    var rxjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(
    /*! rxjs */
    "./node_modules/rxjs/_esm2015/index.js");
    /* harmony import */


    var rxjs_operators__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(
    /*! rxjs/operators */
    "./node_modules/rxjs/_esm2015/operators/index.js");

    var ConfigService = /*#__PURE__*/function () {
      function ConfigService() {
        _classCallCheck(this, ConfigService);
      }

      return _createClass(ConfigService, [{
        key: "storeData",
        value: function storeData(logData, aggData, queryVal, fieldsData, sortValue, similerMessage, similerLogHiglightVal, cacheQuery, XaxisData) {
          var dataObj = {
            tableData: logData,
            chartData: aggData,
            queryValue: queryVal,
            fieldsTable: fieldsData,
            sortVal: sortValue,
            similerMessageCacheVal: similerMessage,
            similerLogHiglightCacheVal: similerLogHiglightVal,
            cacheQueryValue: cacheQuery,
            XaxisData: XaxisData
          };
          this.configs = Object(rxjs__WEBPACK_IMPORTED_MODULE_2__["from"])([dataObj]).pipe(Object(rxjs_operators__WEBPACK_IMPORTED_MODULE_3__["publishReplay"])(1), Object(rxjs_operators__WEBPACK_IMPORTED_MODULE_3__["refCount"])());
        }
      }, {
        key: "getConfigs",
        value: function getConfigs() {
          return this.configs;
        }
      }]);
    }();

    ConfigService = Object(tslib__WEBPACK_IMPORTED_MODULE_0__["__decorate"])([Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["Injectable"])({
      providedIn: 'root'
    })], ConfigService);
    /***/
  },

  /***/
  "./src/app/pages/home/logstab/service/logstab.dummy.ts":
  /*!*************************************************************!*\
    !*** ./src/app/pages/home/logstab/service/logstab.dummy.ts ***!
    \*************************************************************/

  /*! exports provided: LOGS_DATA */

  /***/
  function _src_app_pages_home_logstab_service_logstabDummyTs(module, __webpack_exports__, __webpack_require__) {
    "use strict";

    __webpack_require__.r(__webpack_exports__);
    /* harmony export (binding) */


    __webpack_require__.d(__webpack_exports__, "LOGS_DATA", function () {
      return LOGS_DATA;
    });

    var LOGS_DATA = {
      charts: [{
        title: 'spline Chart',
        highchart: {
          chart: {
            type: 'spline',
            height: '150px'
          },
          title: {
            text: null
          },
          legend: {
            enabled: false
          },
          xAxis: {
            allowDecimals: false,
            accessibility: {
              rangeDescription: 'Range: 1940 to 2017.'
            }
          },
          yAxis: {
            title: {
              text: null
            }
          },
          tooltip: {
            pointFormat: '{series.name} had stockpiled <b>{point.y:,.0f}</b><br/>warheads in {point.x}'
          },
          plotOptions: {
            spline: {
              pointStart: 1940,
              marker: {
                enabled: false,
                symbol: 'circle',
                radius: 2,
                states: {
                  hover: {
                    enabled: true
                  }
                }
              }
            }
          },
          series: [{
            name: 'USA',
            data: [null, null, null, null, null, 6, 11, 32, 110, 235, 369, 640, 1005, 1436, 2063, 3057, 4618, 6444, 9822, 15468, 20434, 24126, 27387, 29459, 31056, 31982, 32040, 31233, 29224, 27342, 26662, 26956, 27912, 28999, 28965, 27826, 25579, 25722, 24826, 24605, 24304, 23464, 23708, 24099, 24357, 24237, 24401, 24344, 23586, 22380, 21004, 17287, 14747, 13076, 12555, 12144, 11009, 10950, 10871, 10824, 10577, 10527, 10475, 10421, 10358, 10295, 10104, 9914, 9620, 9326, 5113, 5113, 4954, 4804, 4761, 4717, 4368, 4018]
          }, {
            name: 'USSR/Russia',
            data: [null, null, null, null, null, null, null, null, null, null, 5, 25, 50, 120, 150, 200, 426, 660, 869, 1060, 1605, 2471, 3322, 4238, 5221, 6129, 7089, 8339, 9399, 10538, 11643, 13092, 14478, 15915, 17385, 19055, 21205, 23044, 25393, 27935, 30062, 32049, 33952, 35804, 37431, 39197, 45000, 43000, 41000, 39000, 37000, 35000, 33000, 31000, 29000, 27000, 25000, 24000, 23000, 22000, 21000, 20000, 19000, 18000, 18000, 17000, 16000, 15537, 14162, 12787, 12600, 11400, 5500, 4512, 4502, 4502, 4500, 4500]
          }]
        }
      }, {
        title: 'Area Chart',
        highchart: {
          chart: {
            type: 'area',
            height: '150px'
          },
          title: {
            text: null
          },
          legend: {
            enabled: false
          },
          xAxis: {
            allowDecimals: false,
            accessibility: {
              rangeDescription: 'Range: 1940 to 2017.'
            }
          },
          yAxis: {
            title: {
              text: null
            }
          },
          tooltip: {
            pointFormat: '{series.name} had stockpiled <b>{point.y:,.0f}</b><br/>warheads in {point.x}'
          },
          plotOptions: {
            area: {
              pointStart: 1940,
              marker: {
                enabled: false,
                symbol: 'circle',
                radius: 2,
                states: {
                  hover: {
                    enabled: true
                  }
                }
              }
            }
          },
          series: [{
            name: 'USA',
            data: [null, null, null, null, null, 6, 11, 32, 110, 235, 369, 640, 1005, 1436, 2063, 3057, 4618, 6444, 9822, 15468, 20434, 24126, 27387, 29459, 31056, 31982, 32040, 31233, 29224, 27342, 26662, 26956, 27912, 28999, 28965, 27826, 25579, 25722, 24826, 24605, 24304, 23464, 23708, 24099, 24357, 24237, 24401, 24344, 23586, 22380, 21004, 17287, 14747, 13076, 12555, 12144, 11009, 10950, 10871, 10824, 10577, 10527, 10475, 10421, 10358, 10295, 10104, 9914, 9620, 9326, 5113, 5113, 4954, 4804, 4761, 4717, 4368, 4018]
          }, {
            name: 'USSR/Russia',
            data: [null, null, null, null, null, null, null, null, null, null, 5, 25, 50, 120, 150, 200, 426, 660, 869, 1060, 1605, 2471, 3322, 4238, 5221, 6129, 7089, 8339, 9399, 10538, 11643, 13092, 14478, 15915, 17385, 19055, 21205, 23044, 25393, 27935, 30062, 32049, 33952, 35804, 37431, 39197, 45000, 43000, 41000, 39000, 37000, 35000, 33000, 31000, 29000, 27000, 25000, 24000, 23000, 22000, 21000, 20000, 19000, 18000, 18000, 17000, 16000, 15537, 14162, 12787, 12600, 11400, 5500, 4512, 4502, 4502, 4500, 4500]
          }]
        }
      }],
      storeTier: [{
        label: 'LRM Maintenance',
        value: ''
      }, {
        label: 'Cavisson Maintenance 2',
        value: ''
      }, {
        label: 'LRM Maintenance',
        value: ''
      }, {
        label: 'Cavisson Maintenance 2',
        value: ''
      }, {
        label: 'LRM Maintenance',
        value: ''
      }, {
        label: 'Cavisson Maintenance 2',
        value: ''
      }, {
        label: 'LRM Maintenance',
        value: ''
      }, {
        label: 'Cavisson Maintenance 2',
        value: ''
      }],
      autocompleteData: [{
        name: 'index=* query=*'
      }, {
        name: 'index=* maxdocs=10000 query=*'
      }],
      timestamp: [],
      tabledata: [],
      fieldsdata: [],
      stats: [],
      pattern: [{
        label: 'Last 10 mins',
        value: 'Last 10 mins'
      }, {
        label: 'Custom',
        value: 'Custom'
      }],
      headers: [{
        cols: [// {
        //   label: '#',
        //   valueField: 'no',
        //   classes: 'text-left',
        //   width: '5%',
        // },
        {
          label: 'Time',
          valueField: 'Time',
          classes: 'timeCol',
          width: '10%',
          selected: true
        }, // {
        //   label: 'Diff(ms)',
        //   valueField: 'Time Diff',
        //   classes: 'docClass',
        //   width: '15%',
        //   selected:false,
        // },
        // {
        //   label: 'Elapse',
        //   valueField: 'Elapsed Col',
        //   classes: 'docClass',
        //   width: '15%',
        // },
        {
          label: 'Log Information',
          valueField: 'keyword',
          classes: 'text-left',
          badgeField: true,
          width: '70%',
          selected: true
        }, {
          label: '',
          valueField: 'icon',
          classes: 'ddrIconClass',
          iconField: true,
          width: '15%',
          selected: true
        }]
      }],
      data: [{
        no: '#',
        time: '23:51:24 02/03/21',
        response: 'Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industrys standard dummy text ever since the 1500s',
        icon: '',
        responseBtns: [{
          label: 'tier: Tomcat4',
          color: 'bg-voilet'
        }, {
          label: 'server: controller',
          color: 'bg-green'
        }, {
          label: 'instance: Instance_1_1_1_1_1_1_1_1',
          color: 'bg-pink'
        }, {
          label: '_index: Tomcat4',
          color: 'bg-yellow'
        }, {
          label: 'message: Tomcat4',
          color: 'bg-yellow'
        }]
      }, {
        no: '#',
        time: '23:51:24 08/01/21',
        response: 'Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industrys standard dummy text ever since the 1500s',
        icon: '',
        responseBtns: [{
          label: 'tier: Tomcat4',
          color: 'bg-voilet'
        }, {
          label: 'server: controller',
          color: 'bg-green'
        }]
      }, {
        no: '#',
        time: '18:51:24 02/03/21',
        response: 'Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industrys standard dummy text ever since the 1500s',
        icon: '',
        responseBtns: [{
          label: 'tier: Tomcat4',
          color: 'bg-voilet'
        }, {
          label: 'server: controller',
          color: 'bg-green'
        }, // {
        //   label: 'instance: Instance_1_1_1_1_1_1_1_1',
        //   color: 'bg-pink',
        // },
        // {
        //   label: '_index: Tomcat4',
        //   color: 'bg-yellow',
        // },
        {
          label: 'message: Tomcat4',
          color: 'bg-yellow'
        }]
      }, {
        no: '#',
        time: '23:51:56 02/01/21',
        response: 'Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industrys standard dummy text ever since the 1500s',
        icon: '',
        responseBtns: [{
          label: 'tier: Tomcat4',
          color: 'bg-voilet'
        }, // {
        //   label: 'server: controller',
        //   color: 'bg-green',
        // },
        // {
        //   label: 'instance: Instance_1_1_1_1_1_1_1_1',
        //   color: 'bg-pink',
        // },
        {
          label: '_index: Tomcat4',
          color: 'bg-yellow'
        }, {
          label: 'message: Tomcat4',
          color: 'bg-yellow'
        }]
      }]
    };
    /***/
  },

  /***/
  8:
  /*!********************!*\
    !*** fs (ignored) ***!
    \********************/

  /*! no static exports found */

  /***/
  function _(module, exports) {
    /* (ignored) */

    /***/
  }
}]);