@chaoswise/business 1.0.3 → 1.0.5

package/lib/AggregateSearch/CLSPL/CLQLParser.js

@@ -1,18 +1,19 @@
-function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+function _get() { return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) { var p = _superPropBase(e, t); if (p) { var n = Object.getOwnPropertyDescriptor(p, t); return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value; } }, _get.apply(null, arguments); }
+function _superPropBase(t, o) { for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t));); return t; }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+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 _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+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 _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); }
 // Generated from /Users/changle/Documents/code/doop/cql/src/main/resources/antlr/cql/CLQLParser.g4 by ANTLR 4.9.2
 // jshint ignore: start
@@ -26,19 +27,18 @@ var decisionsToDFA = atn.decisionToState.map(function (ds, index) {
 });
 var sharedContextCache = new antlr4.PredictionContextCache();
 var CLQLParser = /*#__PURE__*/function (_antlr4$Parser) {
-  _inherits(CLQLParser, _antlr4$Parser);
-  var _super = _createSuper(CLQLParser);
   function CLQLParser(input) {
     var _this;
     _classCallCheck(this, CLQLParser);
-    _this = _super.call(this, input);
-    _this._interp = new antlr4.atn.ParserATNSimulator(_assertThisInitialized(_this), atn, decisionsToDFA, sharedContextCache);
+    _this = _callSuper(this, CLQLParser, [input]);
+    _this._interp = new antlr4.atn.ParserATNSimulator(_this, atn, decisionsToDFA, sharedContextCache);
     _this.ruleNames = CLQLParser.ruleNames;
     _this.literalNames = CLQLParser.literalNames;
     _this.symbolicNames = CLQLParser.symbolicNames;
     return _this;
   }
-  _createClass(CLQLParser, [{
+  _inherits(CLQLParser, _antlr4$Parser);
+  return _createClass(CLQLParser, [{
     key: "atn",
     get: function get() {
       return atn;
@@ -918,7 +918,6 @@ var CLQLParser = /*#__PURE__*/function (_antlr4$Parser) {
       return localctx;
     }
   }]);
-  return CLQLParser;
 }(antlr4.Parser);
 _defineProperty(CLQLParser, "grammarFileName", 'CLQLParser.g4');
 _defineProperty(CLQLParser, "literalNames", [null, "'#'", null, null, null, null, "':'", "'('", "')'", "'<'", "'>'", "'<='", "'>='", "'?'", "'*'", "'['", "']'", "'{'", "'}'", "'~'", "'+'", "'-'"]);
@@ -980,8 +979,6 @@ CLQLParser.RULE_decimal_literal = 18;
 CLQLParser.RULE_comparison_number_operator = 19;
 CLQLParser.RULE_err = 20;
 var RootContext = /*#__PURE__*/function (_antlr4$ParserRuleCon) {
-  _inherits(RootContext, _antlr4$ParserRuleCon);
-  var _super2 = _createSuper(RootContext);
   function RootContext(parser, parent, invokingState) {
     var _this2;
     _classCallCheck(this, RootContext);
@@ -991,12 +988,13 @@ var RootContext = /*#__PURE__*/function (_antlr4$ParserRuleCon) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this2 = _super2.call(this, parent, invokingState);
+    _this2 = _callSuper(this, RootContext, [parent, invokingState]);
     _this2.parser = parser;
     _this2.ruleIndex = CLQLParser.RULE_root;
     return _this2;
   }
-  _createClass(RootContext, [{
+  _inherits(RootContext, _antlr4$ParserRuleCon);
+  return _createClass(RootContext, [{
     key: "EOF",
     value: function EOF() {
       return this.getToken(CLQLParser.EOF, 0);
@@ -1035,11 +1033,8 @@ var RootContext = /*#__PURE__*/function (_antlr4$ParserRuleCon) {
       }
     }
   }]);
-  return RootContext;
 }(antlr4.ParserRuleContext);
 var CqlStatementContext = /*#__PURE__*/function (_antlr4$ParserRuleCon2) {
-  _inherits(CqlStatementContext, _antlr4$ParserRuleCon2);
-  var _super3 = _createSuper(CqlStatementContext);
   function CqlStatementContext(parser, parent, invokingState) {
     var _this3;
     _classCallCheck(this, CqlStatementContext);
@@ -1049,12 +1044,13 @@ var CqlStatementContext = /*#__PURE__*/function (_antlr4$ParserRuleCon2) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this3 = _super3.call(this, parent, invokingState);
+    _this3 = _callSuper(this, CqlStatementContext, [parent, invokingState]);
     _this3.parser = parser;
     _this3.ruleIndex = CLQLParser.RULE_cqlStatement;
     return _this3;
   }
-  _createClass(CqlStatementContext, [{
+  _inherits(CqlStatementContext, _antlr4$ParserRuleCon2);
+  return _createClass(CqlStatementContext, [{
     key: "search",
     value: function search() {
       return this.getTypedRuleContext(SearchContext, 0);
@@ -1083,11 +1079,8 @@ var CqlStatementContext = /*#__PURE__*/function (_antlr4$ParserRuleCon2) {
       }
     }
   }]);
-  return CqlStatementContext;
 }(antlr4.ParserRuleContext);
 var SearchContext = /*#__PURE__*/function (_antlr4$ParserRuleCon3) {
-  _inherits(SearchContext, _antlr4$ParserRuleCon3);
-  var _super4 = _createSuper(SearchContext);
   function SearchContext(parser, parent, invokingState) {
     var _this4;
     _classCallCheck(this, SearchContext);
@@ -1097,8 +1090,8 @@ var SearchContext = /*#__PURE__*/function (_antlr4$ParserRuleCon3) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this4 = _super4.call(this, parent, invokingState);
-    _defineProperty(_assertThisInitialized(_this4), "logical_expr", function (i) {
+    _this4 = _callSuper(this, SearchContext, [parent, invokingState]);
+    _defineProperty(_this4, "logical_expr", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -1112,7 +1105,8 @@ var SearchContext = /*#__PURE__*/function (_antlr4$ParserRuleCon3) {
     _this4.ruleIndex = CLQLParser.RULE_search;
     return _this4;
   }
-  _createClass(SearchContext, [{
+  _inherits(SearchContext, _antlr4$ParserRuleCon3);
+  return _createClass(SearchContext, [{
     key: "enterRule",
     value: function enterRule(listener) {
       if (listener instanceof CLQLParserListener) {
@@ -1136,11 +1130,8 @@ var SearchContext = /*#__PURE__*/function (_antlr4$ParserRuleCon3) {
       }
     }
   }]);
-  return SearchContext;
 }(antlr4.ParserRuleContext);
 var Logical_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon4) {
-  _inherits(Logical_exprContext, _antlr4$ParserRuleCon4);
-  var _super5 = _createSuper(Logical_exprContext);
   function Logical_exprContext(parser, parent, invokingState) {
     var _this5;
     _classCallCheck(this, Logical_exprContext);
@@ -1150,30 +1141,29 @@ var Logical_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon4) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this5 = _super5.call(this, parent, invokingState);
+    _this5 = _callSuper(this, Logical_exprContext, [parent, invokingState]);
     _this5.parser = parser;
     _this5.ruleIndex = CLQLParser.RULE_logical_expr;
     return _this5;
   }
-  _createClass(Logical_exprContext, [{
+  _inherits(Logical_exprContext, _antlr4$ParserRuleCon4);
+  return _createClass(Logical_exprContext, [{
     key: "copyFrom",
     value: function copyFrom(ctx) {
-      _get(_getPrototypeOf(Logical_exprContext.prototype), "copyFrom", this).call(this, ctx);
+      _superPropGet(Logical_exprContext, "copyFrom", this, 3)([ctx]);
     }
   }]);
-  return Logical_exprContext;
 }(antlr4.ParserRuleContext);
 var NotExprContext = /*#__PURE__*/function (_Logical_exprContext) {
-  _inherits(NotExprContext, _Logical_exprContext);
-  var _super6 = _createSuper(NotExprContext);
   function NotExprContext(parser, ctx) {
-    var _thisSuper, _this6;
+    var _this6;
     _classCallCheck(this, NotExprContext);
-    _this6 = _super6.call(this, parser);
-    _get((_thisSuper = _assertThisInitialized(_this6), _getPrototypeOf(NotExprContext.prototype)), "copyFrom", _thisSuper).call(_thisSuper, ctx);
+    _this6 = _callSuper(this, NotExprContext, [parser]);
+    _superPropGet((_this6, NotExprContext), "copyFrom", _this6, 3)([ctx]);
     return _this6;
   }
-  _createClass(NotExprContext, [{
+  _inherits(NotExprContext, _Logical_exprContext);
+  return _createClass(NotExprContext, [{
     key: "K_NOT",
     value: function K_NOT() {
       return this.getToken(CLQLParser.K_NOT, 0);
@@ -1207,20 +1197,18 @@ var NotExprContext = /*#__PURE__*/function (_Logical_exprContext) {
       }
     }
   }]);
-  return NotExprContext;
 }(Logical_exprContext);
 CLQLParser.NotExprContext = NotExprContext;
 var TextExprContext = /*#__PURE__*/function (_Logical_exprContext2) {
-  _inherits(TextExprContext, _Logical_exprContext2);
-  var _super7 = _createSuper(TextExprContext);
   function TextExprContext(parser, ctx) {
-    var _thisSuper2, _this7;
+    var _this7;
     _classCallCheck(this, TextExprContext);
-    _this7 = _super7.call(this, parser);
-    _get((_thisSuper2 = _assertThisInitialized(_this7), _getPrototypeOf(TextExprContext.prototype)), "copyFrom", _thisSuper2).call(_thisSuper2, ctx);
+    _this7 = _callSuper(this, TextExprContext, [parser]);
+    _superPropGet((_this7, TextExprContext), "copyFrom", _this7, 3)([ctx]);
     return _this7;
   }
-  _createClass(TextExprContext, [{
+  _inherits(TextExprContext, _Logical_exprContext2);
+  return _createClass(TextExprContext, [{
     key: "text_expr",
     value: function text_expr() {
       return this.getTypedRuleContext(Text_exprContext, 0);
@@ -1249,17 +1237,14 @@ var TextExprContext = /*#__PURE__*/function (_Logical_exprContext2) {
       }
     }
   }]);
-  return TextExprContext;
 }(Logical_exprContext);
 CLQLParser.TextExprContext = TextExprContext;
 var OrExprContext = /*#__PURE__*/function (_Logical_exprContext3) {
-  _inherits(OrExprContext, _Logical_exprContext3);
-  var _super8 = _createSuper(OrExprContext);
   function OrExprContext(parser, ctx) {
-    var _thisSuper3, _this8;
+    var _this8;
     _classCallCheck(this, OrExprContext);
-    _this8 = _super8.call(this, parser);
-    _defineProperty(_assertThisInitialized(_this8), "logical_expr", function (i) {
+    _this8 = _callSuper(this, OrExprContext, [parser]);
+    _defineProperty(_this8, "logical_expr", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -1271,10 +1256,11 @@ var OrExprContext = /*#__PURE__*/function (_Logical_exprContext3) {
     });
     _this8.left = null; // Logical_exprContext;
     _this8.right = null; // Logical_exprContext;
-    _get((_thisSuper3 = _assertThisInitialized(_this8), _getPrototypeOf(OrExprContext.prototype)), "copyFrom", _thisSuper3).call(_thisSuper3, ctx);
+    _superPropGet((_this8, OrExprContext), "copyFrom", _this8, 3)([ctx]);
     return _this8;
   }
-  _createClass(OrExprContext, [{
+  _inherits(OrExprContext, _Logical_exprContext3);
+  return _createClass(OrExprContext, [{
     key: "K_OR",
     value: function K_OR() {
       return this.getToken(CLQLParser.K_OR, 0);
@@ -1303,20 +1289,18 @@ var OrExprContext = /*#__PURE__*/function (_Logical_exprContext3) {
       }
     }
   }]);
-  return OrExprContext;
 }(Logical_exprContext);
 CLQLParser.OrExprContext = OrExprContext;
 var ComparisonExprContext = /*#__PURE__*/function (_Logical_exprContext4) {
-  _inherits(ComparisonExprContext, _Logical_exprContext4);
-  var _super9 = _createSuper(ComparisonExprContext);
   function ComparisonExprContext(parser, ctx) {
-    var _thisSuper4, _this9;
+    var _this9;
     _classCallCheck(this, ComparisonExprContext);
-    _this9 = _super9.call(this, parser);
-    _get((_thisSuper4 = _assertThisInitialized(_this9), _getPrototypeOf(ComparisonExprContext.prototype)), "copyFrom", _thisSuper4).call(_thisSuper4, ctx);
+    _this9 = _callSuper(this, ComparisonExprContext, [parser]);
+    _superPropGet((_this9, ComparisonExprContext), "copyFrom", _this9, 3)([ctx]);
     return _this9;
   }
-  _createClass(ComparisonExprContext, [{
+  _inherits(ComparisonExprContext, _Logical_exprContext4);
+  return _createClass(ComparisonExprContext, [{
     key: "comparison_expr",
     value: function comparison_expr() {
       return this.getTypedRuleContext(Comparison_exprContext, 0);
@@ -1345,20 +1329,18 @@ var ComparisonExprContext = /*#__PURE__*/function (_Logical_exprContext4) {
       }
     }
   }]);
-  return ComparisonExprContext;
 }(Logical_exprContext);
 CLQLParser.ComparisonExprContext = ComparisonExprContext;
 var FieldExprContext = /*#__PURE__*/function (_Logical_exprContext5) {
-  _inherits(FieldExprContext, _Logical_exprContext5);
-  var _super10 = _createSuper(FieldExprContext);
   function FieldExprContext(parser, ctx) {
-    var _thisSuper5, _this10;
+    var _this10;
     _classCallCheck(this, FieldExprContext);
-    _this10 = _super10.call(this, parser);
-    _get((_thisSuper5 = _assertThisInitialized(_this10), _getPrototypeOf(FieldExprContext.prototype)), "copyFrom", _thisSuper5).call(_thisSuper5, ctx);
+    _this10 = _callSuper(this, FieldExprContext, [parser]);
+    _superPropGet((_this10, FieldExprContext), "copyFrom", _this10, 3)([ctx]);
     return _this10;
   }
-  _createClass(FieldExprContext, [{
+  _inherits(FieldExprContext, _Logical_exprContext5);
+  return _createClass(FieldExprContext, [{
     key: "field_expr",
     value: function field_expr() {
       return this.getTypedRuleContext(Field_exprContext, 0);
@@ -1387,20 +1369,18 @@ var FieldExprContext = /*#__PURE__*/function (_Logical_exprContext5) {
       }
     }
   }]);
-  return FieldExprContext;
 }(Logical_exprContext);
 CLQLParser.FieldExprContext = FieldExprContext;
 var ParenExprContext = /*#__PURE__*/function (_Logical_exprContext6) {
-  _inherits(ParenExprContext, _Logical_exprContext6);
-  var _super11 = _createSuper(ParenExprContext);
   function ParenExprContext(parser, ctx) {
-    var _thisSuper6, _this11;
+    var _this11;
     _classCallCheck(this, ParenExprContext);
-    _this11 = _super11.call(this, parser);
-    _get((_thisSuper6 = _assertThisInitialized(_this11), _getPrototypeOf(ParenExprContext.prototype)), "copyFrom", _thisSuper6).call(_thisSuper6, ctx);
+    _this11 = _callSuper(this, ParenExprContext, [parser]);
+    _superPropGet((_this11, ParenExprContext), "copyFrom", _this11, 3)([ctx]);
     return _this11;
   }
-  _createClass(ParenExprContext, [{
+  _inherits(ParenExprContext, _Logical_exprContext6);
+  return _createClass(ParenExprContext, [{
     key: "LPAREN",
     value: function LPAREN() {
       return this.getToken(CLQLParser.LPAREN, 0);
@@ -1439,17 +1419,14 @@ var ParenExprContext = /*#__PURE__*/function (_Logical_exprContext6) {
       }
     }
   }]);
-  return ParenExprContext;
 }(Logical_exprContext);
 CLQLParser.ParenExprContext = ParenExprContext;
 var AndExprContext = /*#__PURE__*/function (_Logical_exprContext7) {
-  _inherits(AndExprContext, _Logical_exprContext7);
-  var _super12 = _createSuper(AndExprContext);
   function AndExprContext(parser, ctx) {
-    var _thisSuper7, _this12;
+    var _this12;
     _classCallCheck(this, AndExprContext);
-    _this12 = _super12.call(this, parser);
-    _defineProperty(_assertThisInitialized(_this12), "logical_expr", function (i) {
+    _this12 = _callSuper(this, AndExprContext, [parser]);
+    _defineProperty(_this12, "logical_expr", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -1461,10 +1438,11 @@ var AndExprContext = /*#__PURE__*/function (_Logical_exprContext7) {
     });
     _this12.left = null; // Logical_exprContext;
     _this12.right = null; // Logical_exprContext;
-    _get((_thisSuper7 = _assertThisInitialized(_this12), _getPrototypeOf(AndExprContext.prototype)), "copyFrom", _thisSuper7).call(_thisSuper7, ctx);
+    _superPropGet((_this12, AndExprContext), "copyFrom", _this12, 3)([ctx]);
     return _this12;
   }
-  _createClass(AndExprContext, [{
+  _inherits(AndExprContext, _Logical_exprContext7);
+  return _createClass(AndExprContext, [{
     key: "K_AND",
     value: function K_AND() {
       return this.getToken(CLQLParser.K_AND, 0);
@@ -1493,12 +1471,9 @@ var AndExprContext = /*#__PURE__*/function (_Logical_exprContext7) {
       }
     }
   }]);
-  return AndExprContext;
 }(Logical_exprContext);
 CLQLParser.AndExprContext = AndExprContext;
 var Text_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon5) {
-  _inherits(Text_exprContext, _antlr4$ParserRuleCon5);
-  var _super13 = _createSuper(Text_exprContext);
   function Text_exprContext(parser, parent, invokingState) {
     var _this13;
     _classCallCheck(this, Text_exprContext);
@@ -1508,30 +1483,29 @@ var Text_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon5) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this13 = _super13.call(this, parent, invokingState);
+    _this13 = _callSuper(this, Text_exprContext, [parent, invokingState]);
     _this13.parser = parser;
     _this13.ruleIndex = CLQLParser.RULE_text_expr;
     return _this13;
   }
-  _createClass(Text_exprContext, [{
+  _inherits(Text_exprContext, _antlr4$ParserRuleCon5);
+  return _createClass(Text_exprContext, [{
     key: "copyFrom",
     value: function copyFrom(ctx) {
-      _get(_getPrototypeOf(Text_exprContext.prototype), "copyFrom", this).call(this, ctx);
+      _superPropGet(Text_exprContext, "copyFrom", this, 3)([ctx]);
     }
   }]);
-  return Text_exprContext;
 }(antlr4.ParserRuleContext);
 var TextSearchExprContext = /*#__PURE__*/function (_Text_exprContext) {
-  _inherits(TextSearchExprContext, _Text_exprContext);
-  var _super14 = _createSuper(TextSearchExprContext);
   function TextSearchExprContext(parser, ctx) {
-    var _thisSuper8, _this14;
+    var _this14;
     _classCallCheck(this, TextSearchExprContext);
-    _this14 = _super14.call(this, parser);
-    _get((_thisSuper8 = _assertThisInitialized(_this14), _getPrototypeOf(TextSearchExprContext.prototype)), "copyFrom", _thisSuper8).call(_thisSuper8, ctx);
+    _this14 = _callSuper(this, TextSearchExprContext, [parser]);
+    _superPropGet((_this14, TextSearchExprContext), "copyFrom", _this14, 3)([ctx]);
     return _this14;
   }
-  _createClass(TextSearchExprContext, [{
+  _inherits(TextSearchExprContext, _Text_exprContext);
+  return _createClass(TextSearchExprContext, [{
     key: "text_search_expr",
     value: function text_search_expr() {
       return this.getTypedRuleContext(Text_search_exprContext, 0);
@@ -1560,20 +1534,18 @@ var TextSearchExprContext = /*#__PURE__*/function (_Text_exprContext) {
       }
     }
   }]);
-  return TextSearchExprContext;
 }(Text_exprContext);
 CLQLParser.TextSearchExprContext = TextSearchExprContext;
 var TextRegexExprContext = /*#__PURE__*/function (_Text_exprContext2) {
-  _inherits(TextRegexExprContext, _Text_exprContext2);
-  var _super15 = _createSuper(TextRegexExprContext);
   function TextRegexExprContext(parser, ctx) {
-    var _thisSuper9, _this15;
+    var _this15;
     _classCallCheck(this, TextRegexExprContext);
-    _this15 = _super15.call(this, parser);
-    _get((_thisSuper9 = _assertThisInitialized(_this15), _getPrototypeOf(TextRegexExprContext.prototype)), "copyFrom", _thisSuper9).call(_thisSuper9, ctx);
+    _this15 = _callSuper(this, TextRegexExprContext, [parser]);
+    _superPropGet((_this15, TextRegexExprContext), "copyFrom", _this15, 3)([ctx]);
     return _this15;
   }
-  _createClass(TextRegexExprContext, [{
+  _inherits(TextRegexExprContext, _Text_exprContext2);
+  return _createClass(TextRegexExprContext, [{
     key: "text_regex_expr",
     value: function text_regex_expr() {
       return this.getTypedRuleContext(Text_regex_exprContext, 0);
@@ -1602,20 +1574,18 @@ var TextRegexExprContext = /*#__PURE__*/function (_Text_exprContext2) {
       }
     }
   }]);
-  return TextRegexExprContext;
 }(Text_exprContext);
 CLQLParser.TextRegexExprContext = TextRegexExprContext;
 var TextRegexModelExprContext = /*#__PURE__*/function (_Text_exprContext3) {
-  _inherits(TextRegexModelExprContext, _Text_exprContext3);
-  var _super16 = _createSuper(TextRegexModelExprContext);
   function TextRegexModelExprContext(parser, ctx) {
-    var _thisSuper10, _this16;
+    var _this16;
     _classCallCheck(this, TextRegexModelExprContext);
-    _this16 = _super16.call(this, parser);
-    _get((_thisSuper10 = _assertThisInitialized(_this16), _getPrototypeOf(TextRegexModelExprContext.prototype)), "copyFrom", _thisSuper10).call(_thisSuper10, ctx);
+    _this16 = _callSuper(this, TextRegexModelExprContext, [parser]);
+    _superPropGet((_this16, TextRegexModelExprContext), "copyFrom", _this16, 3)([ctx]);
     return _this16;
   }
-  _createClass(TextRegexModelExprContext, [{
+  _inherits(TextRegexModelExprContext, _Text_exprContext3);
+  return _createClass(TextRegexModelExprContext, [{
     key: "text_regex_model_expr",
     value: function text_regex_model_expr() {
       return this.getTypedRuleContext(Text_regex_model_exprContext, 0);
@@ -1644,12 +1614,9 @@ var TextRegexModelExprContext = /*#__PURE__*/function (_Text_exprContext3) {
       }
     }
   }]);
-  return TextRegexModelExprContext;
 }(Text_exprContext);
 CLQLParser.TextRegexModelExprContext = TextRegexModelExprContext;
 var Text_regex_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon6) {
-  _inherits(Text_regex_exprContext, _antlr4$ParserRuleCon6);
-  var _super17 = _createSuper(Text_regex_exprContext);
   function Text_regex_exprContext(parser, parent, invokingState) {
     var _this17;
     _classCallCheck(this, Text_regex_exprContext);
@@ -1659,12 +1626,13 @@ var Text_regex_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon6) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this17 = _super17.call(this, parent, invokingState);
+    _this17 = _callSuper(this, Text_regex_exprContext, [parent, invokingState]);
     _this17.parser = parser;
     _this17.ruleIndex = CLQLParser.RULE_text_regex_expr;
     return _this17;
   }
-  _createClass(Text_regex_exprContext, [{
+  _inherits(Text_regex_exprContext, _antlr4$ParserRuleCon6);
+  return _createClass(Text_regex_exprContext, [{
     key: "REGEX",
     value: function REGEX() {
       return this.getToken(CLQLParser.REGEX, 0);
@@ -1693,11 +1661,8 @@ var Text_regex_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon6) {
       }
     }
   }]);
-  return Text_regex_exprContext;
 }(antlr4.ParserRuleContext);
 var Text_regex_model_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon7) {
-  _inherits(Text_regex_model_exprContext, _antlr4$ParserRuleCon7);
-  var _super18 = _createSuper(Text_regex_model_exprContext);
   function Text_regex_model_exprContext(parser, parent, invokingState) {
     var _this18;
     _classCallCheck(this, Text_regex_model_exprContext);
@@ -1707,8 +1672,8 @@ var Text_regex_model_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon7
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this18 = _super18.call(this, parent, invokingState);
-    _defineProperty(_assertThisInitialized(_this18), "WEI", function (i) {
+    _this18 = _callSuper(this, Text_regex_model_exprContext, [parent, invokingState]);
+    _defineProperty(_this18, "WEI", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -1718,7 +1683,7 @@ var Text_regex_model_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon7
         return this.getToken(CLQLParser.WEI, i);
       }
     });
-    _defineProperty(_assertThisInitialized(_this18), "BQUOTA_STRING", function (i) {
+    _defineProperty(_this18, "BQUOTA_STRING", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -1728,7 +1693,7 @@ var Text_regex_model_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon7
         return this.getToken(CLQLParser.BQUOTA_STRING, i);
       }
     });
-    _defineProperty(_assertThisInitialized(_this18), "STAR", function (i) {
+    _defineProperty(_this18, "STAR", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -1742,7 +1707,8 @@ var Text_regex_model_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon7
     _this18.ruleIndex = CLQLParser.RULE_text_regex_model_expr;
     return _this18;
   }
-  _createClass(Text_regex_model_exprContext, [{
+  _inherits(Text_regex_model_exprContext, _antlr4$ParserRuleCon7);
+  return _createClass(Text_regex_model_exprContext, [{
     key: "enterRule",
     value: function enterRule(listener) {
       if (listener instanceof CLQLParserListener) {
@@ -1766,11 +1732,8 @@ var Text_regex_model_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon7
       }
     }
   }]);
-  return Text_regex_model_exprContext;
 }(antlr4.ParserRuleContext);
 var Comparison_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon8) {
-  _inherits(Comparison_exprContext, _antlr4$ParserRuleCon8);
-  var _super19 = _createSuper(Comparison_exprContext);
   function Comparison_exprContext(parser, parent, invokingState) {
     var _this19;
     _classCallCheck(this, Comparison_exprContext);
@@ -1780,27 +1743,25 @@ var Comparison_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon8) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this19 = _super19.call(this, parent, invokingState);
+    _this19 = _callSuper(this, Comparison_exprContext, [parent, invokingState]);
     _this19.parser = parser;
     _this19.ruleIndex = CLQLParser.RULE_comparison_expr;
     return _this19;
   }
-  _createClass(Comparison_exprContext, [{
+  _inherits(Comparison_exprContext, _antlr4$ParserRuleCon8);
+  return _createClass(Comparison_exprContext, [{
     key: "copyFrom",
     value: function copyFrom(ctx) {
-      _get(_getPrototypeOf(Comparison_exprContext.prototype), "copyFrom", this).call(this, ctx);
+      _superPropGet(Comparison_exprContext, "copyFrom", this, 3)([ctx]);
     }
   }]);
-  return Comparison_exprContext;
 }(antlr4.ParserRuleContext);
 var NumberCompareExprContext = /*#__PURE__*/function (_Comparison_exprConte) {
-  _inherits(NumberCompareExprContext, _Comparison_exprConte);
-  var _super20 = _createSuper(NumberCompareExprContext);
   function NumberCompareExprContext(parser, ctx) {
-    var _thisSuper11, _this20;
+    var _this20;
     _classCallCheck(this, NumberCompareExprContext);
-    _this20 = _super20.call(this, parser);
-    _defineProperty(_assertThisInitialized(_this20), "primary_expr", function (i) {
+    _this20 = _callSuper(this, NumberCompareExprContext, [parser]);
+    _defineProperty(_this20, "primary_expr", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -1812,10 +1773,11 @@ var NumberCompareExprContext = /*#__PURE__*/function (_Comparison_exprConte) {
     });
     _this20.left = null; // Primary_exprContext;
     _this20.right = null; // Primary_exprContext;
-    _get((_thisSuper11 = _assertThisInitialized(_this20), _getPrototypeOf(NumberCompareExprContext.prototype)), "copyFrom", _thisSuper11).call(_thisSuper11, ctx);
+    _superPropGet((_this20, NumberCompareExprContext), "copyFrom", _this20, 3)([ctx]);
     return _this20;
   }
-  _createClass(NumberCompareExprContext, [{
+  _inherits(NumberCompareExprContext, _Comparison_exprConte);
+  return _createClass(NumberCompareExprContext, [{
     key: "comparison_number_operator",
     value: function comparison_number_operator() {
       return this.getTypedRuleContext(Comparison_number_operatorContext, 0);
@@ -1844,12 +1806,9 @@ var NumberCompareExprContext = /*#__PURE__*/function (_Comparison_exprConte) {
       }
     }
   }]);
-  return NumberCompareExprContext;
 }(Comparison_exprContext);
 CLQLParser.NumberCompareExprContext = NumberCompareExprContext;
 var Field_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon9) {
-  _inherits(Field_exprContext, _antlr4$ParserRuleCon9);
-  var _super21 = _createSuper(Field_exprContext);
   function Field_exprContext(parser, parent, invokingState) {
     var _this21;
     _classCallCheck(this, Field_exprContext);
@@ -1859,27 +1818,25 @@ var Field_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon9) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this21 = _super21.call(this, parent, invokingState);
+    _this21 = _callSuper(this, Field_exprContext, [parent, invokingState]);
     _this21.parser = parser;
     _this21.ruleIndex = CLQLParser.RULE_field_expr;
     return _this21;
   }
-  _createClass(Field_exprContext, [{
+  _inherits(Field_exprContext, _antlr4$ParserRuleCon9);
+  return _createClass(Field_exprContext, [{
     key: "copyFrom",
     value: function copyFrom(ctx) {
-      _get(_getPrototypeOf(Field_exprContext.prototype), "copyFrom", this).call(this, ctx);
+      _superPropGet(Field_exprContext, "copyFrom", this, 3)([ctx]);
     }
   }]);
-  return Field_exprContext;
 }(antlr4.ParserRuleContext);
 var FieldRangeExprContext = /*#__PURE__*/function (_Field_exprContext) {
-  _inherits(FieldRangeExprContext, _Field_exprContext);
-  var _super22 = _createSuper(FieldRangeExprContext);
   function FieldRangeExprContext(parser, ctx) {
-    var _thisSuper12, _this22;
+    var _this22;
     _classCallCheck(this, FieldRangeExprContext);
-    _this22 = _super22.call(this, parser);
-    _defineProperty(_assertThisInitialized(_this22), "number_literal", function (i) {
+    _this22 = _callSuper(this, FieldRangeExprContext, [parser]);
+    _defineProperty(_this22, "number_literal", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -1889,10 +1846,11 @@ var FieldRangeExprContext = /*#__PURE__*/function (_Field_exprContext) {
         return this.getTypedRuleContext(Number_literalContext, i);
       }
     });
-    _get((_thisSuper12 = _assertThisInitialized(_this22), _getPrototypeOf(FieldRangeExprContext.prototype)), "copyFrom", _thisSuper12).call(_thisSuper12, ctx);
+    _superPropGet((_this22, FieldRangeExprContext), "copyFrom", _this22, 3)([ctx]);
     return _this22;
   }
-  _createClass(FieldRangeExprContext, [{
+  _inherits(FieldRangeExprContext, _Field_exprContext);
+  return _createClass(FieldRangeExprContext, [{
     key: "field",
     value: function field() {
       return this.getTypedRuleContext(FieldContext, 0);
@@ -1951,22 +1909,20 @@ var FieldRangeExprContext = /*#__PURE__*/function (_Field_exprContext) {
       }
     }
   }]);
-  return FieldRangeExprContext;
 }(Field_exprContext);
 CLQLParser.FieldRangeExprContext = FieldRangeExprContext;
 var FieldValueExprContext = /*#__PURE__*/function (_Field_exprContext2) {
-  _inherits(FieldValueExprContext, _Field_exprContext2);
-  var _super23 = _createSuper(FieldValueExprContext);
   function FieldValueExprContext(parser, ctx) {
-    var _thisSuper13, _this23;
+    var _this23;
     _classCallCheck(this, FieldValueExprContext);
-    _this23 = _super23.call(this, parser);
+    _this23 = _callSuper(this, FieldValueExprContext, [parser]);
     _this23.left = null; // FieldContext;
     _this23.right = null; // Fuzzy_literal_valueContext;
-    _get((_thisSuper13 = _assertThisInitialized(_this23), _getPrototypeOf(FieldValueExprContext.prototype)), "copyFrom", _thisSuper13).call(_thisSuper13, ctx);
+    _superPropGet((_this23, FieldValueExprContext), "copyFrom", _this23, 3)([ctx]);
     return _this23;
   }
-  _createClass(FieldValueExprContext, [{
+  _inherits(FieldValueExprContext, _Field_exprContext2);
+  return _createClass(FieldValueExprContext, [{
     key: "COLON",
     value: function COLON() {
       return this.getToken(CLQLParser.COLON, 0);
@@ -2005,17 +1961,14 @@ var FieldValueExprContext = /*#__PURE__*/function (_Field_exprContext2) {
       }
     }
   }]);
-  return FieldValueExprContext;
 }(Field_exprContext);
 CLQLParser.FieldValueExprContext = FieldValueExprContext;
 var FieldInExprContext = /*#__PURE__*/function (_Field_exprContext3) {
-  _inherits(FieldInExprContext, _Field_exprContext3);
-  var _super24 = _createSuper(FieldInExprContext);
   function FieldInExprContext(parser, ctx) {
-    var _thisSuper14, _this24;
+    var _this24;
     _classCallCheck(this, FieldInExprContext);
-    _this24 = _super24.call(this, parser);
-    _defineProperty(_assertThisInitialized(_this24), "literal_value", function (i) {
+    _this24 = _callSuper(this, FieldInExprContext, [parser]);
+    _defineProperty(_this24, "literal_value", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -2025,7 +1978,7 @@ var FieldInExprContext = /*#__PURE__*/function (_Field_exprContext3) {
         return this.getTypedRuleContext(Literal_valueContext, i);
       }
     });
-    _defineProperty(_assertThisInitialized(_this24), "K_OR", function (i) {
+    _defineProperty(_this24, "K_OR", function (i) {
       if (i === undefined) {
         i = null;
       }
@@ -2035,10 +1988,11 @@ var FieldInExprContext = /*#__PURE__*/function (_Field_exprContext3) {
         return this.getToken(CLQLParser.K_OR, i);
       }
     });
-    _get((_thisSuper14 = _assertThisInitialized(_this24), _getPrototypeOf(FieldInExprContext.prototype)), "copyFrom", _thisSuper14).call(_thisSuper14, ctx);
+    _superPropGet((_this24, FieldInExprContext), "copyFrom", _this24, 3)([ctx]);
     return _this24;
   }
-  _createClass(FieldInExprContext, [{
+  _inherits(FieldInExprContext, _Field_exprContext3);
+  return _createClass(FieldInExprContext, [{
     key: "field",
     value: function field() {
       return this.getTypedRuleContext(FieldContext, 0);
@@ -2082,20 +2036,18 @@ var FieldInExprContext = /*#__PURE__*/function (_Field_exprContext3) {
       }
     }
   }]);
-  return FieldInExprContext;
 }(Field_exprContext);
 CLQLParser.FieldInExprContext = FieldInExprContext;
 var FieldExistExprContext = /*#__PURE__*/function (_Field_exprContext4) {
-  _inherits(FieldExistExprContext, _Field_exprContext4);
-  var _super25 = _createSuper(FieldExistExprContext);
   function FieldExistExprContext(parser, ctx) {
-    var _thisSuper15, _this25;
+    var _this25;
     _classCallCheck(this, FieldExistExprContext);
-    _this25 = _super25.call(this, parser);
-    _get((_thisSuper15 = _assertThisInitialized(_this25), _getPrototypeOf(FieldExistExprContext.prototype)), "copyFrom", _thisSuper15).call(_thisSuper15, ctx);
+    _this25 = _callSuper(this, FieldExistExprContext, [parser]);
+    _superPropGet((_this25, FieldExistExprContext), "copyFrom", _this25, 3)([ctx]);
     return _this25;
   }
-  _createClass(FieldExistExprContext, [{
+  _inherits(FieldExistExprContext, _Field_exprContext4);
+  return _createClass(FieldExistExprContext, [{
     key: "WAVE",
     value: function WAVE() {
       return this.getToken(CLQLParser.WAVE, 0);
@@ -2129,12 +2081,9 @@ var FieldExistExprContext = /*#__PURE__*/function (_Field_exprContext4) {
       }
     }
   }]);
-  return FieldExistExprContext;
 }(Field_exprContext);
 CLQLParser.FieldExistExprContext = FieldExistExprContext;
 var Text_search_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon10) {
-  _inherits(Text_search_exprContext, _antlr4$ParserRuleCon10);
-  var _super26 = _createSuper(Text_search_exprContext);
   function Text_search_exprContext(parser, parent, invokingState) {
     var _this26;
     _classCallCheck(this, Text_search_exprContext);
@@ -2144,12 +2093,13 @@ var Text_search_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon10) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this26 = _super26.call(this, parent, invokingState);
+    _this26 = _callSuper(this, Text_search_exprContext, [parent, invokingState]);
     _this26.parser = parser;
     _this26.ruleIndex = CLQLParser.RULE_text_search_expr;
     return _this26;
   }
-  _createClass(Text_search_exprContext, [{
+  _inherits(Text_search_exprContext, _antlr4$ParserRuleCon10);
+  return _createClass(Text_search_exprContext, [{
     key: "fuzzy_literal_value",
     value: function fuzzy_literal_value() {
       return this.getTypedRuleContext(Fuzzy_literal_valueContext, 0);
@@ -2178,11 +2128,8 @@ var Text_search_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon10) {
       }
     }
   }]);
-  return Text_search_exprContext;
 }(antlr4.ParserRuleContext);
 var Primary_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon11) {
-  _inherits(Primary_exprContext, _antlr4$ParserRuleCon11);
-  var _super27 = _createSuper(Primary_exprContext);
   function Primary_exprContext(parser, parent, invokingState) {
     var _this27;
     _classCallCheck(this, Primary_exprContext);
@@ -2192,12 +2139,13 @@ var Primary_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon11) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this27 = _super27.call(this, parent, invokingState);
+    _this27 = _callSuper(this, Primary_exprContext, [parent, invokingState]);
     _this27.parser = parser;
     _this27.ruleIndex = CLQLParser.RULE_primary_expr;
     return _this27;
   }
-  _createClass(Primary_exprContext, [{
+  _inherits(Primary_exprContext, _antlr4$ParserRuleCon11);
+  return _createClass(Primary_exprContext, [{
     key: "field",
     value: function field() {
       return this.getTypedRuleContext(FieldContext, 0);
@@ -2231,11 +2179,8 @@ var Primary_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon11) {
       }
     }
   }]);
-  return Primary_exprContext;
 }(antlr4.ParserRuleContext);
 var FieldContext = /*#__PURE__*/function (_antlr4$ParserRuleCon12) {
-  _inherits(FieldContext, _antlr4$ParserRuleCon12);
-  var _super28 = _createSuper(FieldContext);
   function FieldContext(parser, parent, invokingState) {
     var _this28;
     _classCallCheck(this, FieldContext);
@@ -2245,12 +2190,13 @@ var FieldContext = /*#__PURE__*/function (_antlr4$ParserRuleCon12) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this28 = _super28.call(this, parent, invokingState);
+    _this28 = _callSuper(this, FieldContext, [parent, invokingState]);
     _this28.parser = parser;
     _this28.ruleIndex = CLQLParser.RULE_field;
     return _this28;
   }
-  _createClass(FieldContext, [{
+  _inherits(FieldContext, _antlr4$ParserRuleCon12);
+  return _createClass(FieldContext, [{
     key: "UNQUOTA_STRING",
     value: function UNQUOTA_STRING() {
       return this.getToken(CLQLParser.UNQUOTA_STRING, 0);
@@ -2279,11 +2225,8 @@ var FieldContext = /*#__PURE__*/function (_antlr4$ParserRuleCon12) {
       }
     }
   }]);
-  return FieldContext;
 }(antlr4.ParserRuleContext);
 var Fuzzy_literal_valueContext = /*#__PURE__*/function (_antlr4$ParserRuleCon13) {
-  _inherits(Fuzzy_literal_valueContext, _antlr4$ParserRuleCon13);
-  var _super29 = _createSuper(Fuzzy_literal_valueContext);
   function Fuzzy_literal_valueContext(parser, parent, invokingState) {
     var _this29;
     _classCallCheck(this, Fuzzy_literal_valueContext);
@@ -2293,12 +2236,13 @@ var Fuzzy_literal_valueContext = /*#__PURE__*/function (_antlr4$ParserRuleCon13)
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this29 = _super29.call(this, parent, invokingState);
+    _this29 = _callSuper(this, Fuzzy_literal_valueContext, [parent, invokingState]);
     _this29.parser = parser;
     _this29.ruleIndex = CLQLParser.RULE_fuzzy_literal_value;
     return _this29;
   }
-  _createClass(Fuzzy_literal_valueContext, [{
+  _inherits(Fuzzy_literal_valueContext, _antlr4$ParserRuleCon13);
+  return _createClass(Fuzzy_literal_valueContext, [{
     key: "fuzzy_literal",
     value: function fuzzy_literal() {
       return this.getTypedRuleContext(Fuzzy_literalContext, 0);
@@ -2332,11 +2276,8 @@ var Fuzzy_literal_valueContext = /*#__PURE__*/function (_antlr4$ParserRuleCon13)
       }
     }
   }]);
-  return Fuzzy_literal_valueContext;
 }(antlr4.ParserRuleContext);
 var Fuzzy_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon14) {
-  _inherits(Fuzzy_literalContext, _antlr4$ParserRuleCon14);
-  var _super30 = _createSuper(Fuzzy_literalContext);
   function Fuzzy_literalContext(parser, parent, invokingState) {
     var _this30;
     _classCallCheck(this, Fuzzy_literalContext);
@@ -2346,12 +2287,13 @@ var Fuzzy_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon14) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this30 = _super30.call(this, parent, invokingState);
+    _this30 = _callSuper(this, Fuzzy_literalContext, [parent, invokingState]);
     _this30.parser = parser;
     _this30.ruleIndex = CLQLParser.RULE_fuzzy_literal;
     return _this30;
   }
-  _createClass(Fuzzy_literalContext, [{
+  _inherits(Fuzzy_literalContext, _antlr4$ParserRuleCon14);
+  return _createClass(Fuzzy_literalContext, [{
     key: "FUZZY_LITERAL",
     value: function FUZZY_LITERAL() {
       return this.getToken(CLQLParser.FUZZY_LITERAL, 0);
@@ -2380,11 +2322,8 @@ var Fuzzy_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon14) {
       }
     }
   }]);
-  return Fuzzy_literalContext;
 }(antlr4.ParserRuleContext);
 var Literal_valueContext = /*#__PURE__*/function (_antlr4$ParserRuleCon15) {
-  _inherits(Literal_valueContext, _antlr4$ParserRuleCon15);
-  var _super31 = _createSuper(Literal_valueContext);
   function Literal_valueContext(parser, parent, invokingState) {
     var _this31;
     _classCallCheck(this, Literal_valueContext);
@@ -2394,12 +2333,13 @@ var Literal_valueContext = /*#__PURE__*/function (_antlr4$ParserRuleCon15) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this31 = _super31.call(this, parent, invokingState);
+    _this31 = _callSuper(this, Literal_valueContext, [parent, invokingState]);
     _this31.parser = parser;
     _this31.ruleIndex = CLQLParser.RULE_literal_value;
     return _this31;
   }
-  _createClass(Literal_valueContext, [{
+  _inherits(Literal_valueContext, _antlr4$ParserRuleCon15);
+  return _createClass(Literal_valueContext, [{
     key: "string_literal",
     value: function string_literal() {
       return this.getTypedRuleContext(String_literalContext, 0);
@@ -2433,11 +2373,8 @@ var Literal_valueContext = /*#__PURE__*/function (_antlr4$ParserRuleCon15) {
       }
     }
   }]);
-  return Literal_valueContext;
 }(antlr4.ParserRuleContext);
 var String_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon16) {
-  _inherits(String_literalContext, _antlr4$ParserRuleCon16);
-  var _super32 = _createSuper(String_literalContext);
   function String_literalContext(parser, parent, invokingState) {
     var _this32;
     _classCallCheck(this, String_literalContext);
@@ -2447,12 +2384,13 @@ var String_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon16) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this32 = _super32.call(this, parent, invokingState);
+    _this32 = _callSuper(this, String_literalContext, [parent, invokingState]);
     _this32.parser = parser;
     _this32.ruleIndex = CLQLParser.RULE_string_literal;
     return _this32;
   }
-  _createClass(String_literalContext, [{
+  _inherits(String_literalContext, _antlr4$ParserRuleCon16);
+  return _createClass(String_literalContext, [{
     key: "UNQUOTA_STRING",
     value: function UNQUOTA_STRING() {
       return this.getToken(CLQLParser.UNQUOTA_STRING, 0);
@@ -2486,11 +2424,8 @@ var String_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon16) {
       }
     }
   }]);
-  return String_literalContext;
 }(antlr4.ParserRuleContext);
 var Number_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon17) {
-  _inherits(Number_literalContext, _antlr4$ParserRuleCon17);
-  var _super33 = _createSuper(Number_literalContext);
   function Number_literalContext(parser, parent, invokingState) {
     var _this33;
     _classCallCheck(this, Number_literalContext);
@@ -2500,12 +2435,13 @@ var Number_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon17) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this33 = _super33.call(this, parent, invokingState);
+    _this33 = _callSuper(this, Number_literalContext, [parent, invokingState]);
     _this33.parser = parser;
     _this33.ruleIndex = CLQLParser.RULE_number_literal;
     return _this33;
   }
-  _createClass(Number_literalContext, [{
+  _inherits(Number_literalContext, _antlr4$ParserRuleCon17);
+  return _createClass(Number_literalContext, [{
     key: "integer_literal",
     value: function integer_literal() {
       return this.getTypedRuleContext(Integer_literalContext, 0);
@@ -2539,11 +2475,8 @@ var Number_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon17) {
       }
     }
   }]);
-  return Number_literalContext;
 }(antlr4.ParserRuleContext);
 var Integer_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon18) {
-  _inherits(Integer_literalContext, _antlr4$ParserRuleCon18);
-  var _super34 = _createSuper(Integer_literalContext);
   function Integer_literalContext(parser, parent, invokingState) {
     var _this34;
     _classCallCheck(this, Integer_literalContext);
@@ -2553,12 +2486,13 @@ var Integer_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon18) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this34 = _super34.call(this, parent, invokingState);
+    _this34 = _callSuper(this, Integer_literalContext, [parent, invokingState]);
     _this34.parser = parser;
     _this34.ruleIndex = CLQLParser.RULE_integer_literal;
     return _this34;
   }
-  _createClass(Integer_literalContext, [{
+  _inherits(Integer_literalContext, _antlr4$ParserRuleCon18);
+  return _createClass(Integer_literalContext, [{
     key: "INTEGER_LITERAL",
     value: function INTEGER_LITERAL() {
       return this.getToken(CLQLParser.INTEGER_LITERAL, 0);
@@ -2597,11 +2531,8 @@ var Integer_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon18) {
       }
     }
   }]);
-  return Integer_literalContext;
 }(antlr4.ParserRuleContext);
 var Decimal_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon19) {
-  _inherits(Decimal_literalContext, _antlr4$ParserRuleCon19);
-  var _super35 = _createSuper(Decimal_literalContext);
   function Decimal_literalContext(parser, parent, invokingState) {
     var _this35;
     _classCallCheck(this, Decimal_literalContext);
@@ -2611,12 +2542,13 @@ var Decimal_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon19) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this35 = _super35.call(this, parent, invokingState);
+    _this35 = _callSuper(this, Decimal_literalContext, [parent, invokingState]);
     _this35.parser = parser;
     _this35.ruleIndex = CLQLParser.RULE_decimal_literal;
     return _this35;
   }
-  _createClass(Decimal_literalContext, [{
+  _inherits(Decimal_literalContext, _antlr4$ParserRuleCon19);
+  return _createClass(Decimal_literalContext, [{
     key: "DECIMAL_LITERAL",
     value: function DECIMAL_LITERAL() {
       return this.getToken(CLQLParser.DECIMAL_LITERAL, 0);
@@ -2660,11 +2592,8 @@ var Decimal_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon19) {
       }
     }
   }]);
-  return Decimal_literalContext;
 }(antlr4.ParserRuleContext);
 var Comparison_number_operatorContext = /*#__PURE__*/function (_antlr4$ParserRuleCon20) {
-  _inherits(Comparison_number_operatorContext, _antlr4$ParserRuleCon20);
-  var _super36 = _createSuper(Comparison_number_operatorContext);
   function Comparison_number_operatorContext(parser, parent, invokingState) {
     var _this36;
     _classCallCheck(this, Comparison_number_operatorContext);
@@ -2674,12 +2603,13 @@ var Comparison_number_operatorContext = /*#__PURE__*/function (_antlr4$ParserRul
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this36 = _super36.call(this, parent, invokingState);
+    _this36 = _callSuper(this, Comparison_number_operatorContext, [parent, invokingState]);
     _this36.parser = parser;
     _this36.ruleIndex = CLQLParser.RULE_comparison_number_operator;
     return _this36;
   }
-  _createClass(Comparison_number_operatorContext, [{
+  _inherits(Comparison_number_operatorContext, _antlr4$ParserRuleCon20);
+  return _createClass(Comparison_number_operatorContext, [{
     key: "LT",
     value: function LT() {
       return this.getToken(CLQLParser.LT, 0);
@@ -2723,11 +2653,8 @@ var Comparison_number_operatorContext = /*#__PURE__*/function (_antlr4$ParserRul
       }
     }
   }]);
-  return Comparison_number_operatorContext;
 }(antlr4.ParserRuleContext);
 var ErrContext = /*#__PURE__*/function (_antlr4$ParserRuleCon21) {
-  _inherits(ErrContext, _antlr4$ParserRuleCon21);
-  var _super37 = _createSuper(ErrContext);
   function ErrContext(parser, parent, invokingState) {
     var _this37;
     _classCallCheck(this, ErrContext);
@@ -2737,13 +2664,14 @@ var ErrContext = /*#__PURE__*/function (_antlr4$ParserRuleCon21) {
     if (invokingState === undefined || invokingState === null) {
       invokingState = -1;
     }
-    _this37 = _super37.call(this, parent, invokingState);
+    _this37 = _callSuper(this, ErrContext, [parent, invokingState]);
     _this37.parser = parser;
     _this37.ruleIndex = CLQLParser.RULE_err;
     _this37._UNEXPECTED_CHAR = null; // Token
     return _this37;
   }
-  _createClass(ErrContext, [{
+  _inherits(ErrContext, _antlr4$ParserRuleCon21);
+  return _createClass(ErrContext, [{
     key: "UNEXPECTED_CHAR",
     value: function UNEXPECTED_CHAR() {
       return this.getToken(CLQLParser.UNEXPECTED_CHAR, 0);
@@ -2772,7 +2700,6 @@ var ErrContext = /*#__PURE__*/function (_antlr4$ParserRuleCon21) {
       }
     }
   }]);
-  return ErrContext;
 }(antlr4.ParserRuleContext);
 CLQLParser.RootContext = RootContext;
 CLQLParser.CqlStatementContext = CqlStatementContext;