@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/vendor/aql/parser/parser.js

@@ -0,0 +1,934 @@
+//@ts-nocheck
+/* parser generated by jison 0.4.18 */
+/*
+  Returns a Parser object of the following structure:
+
+  Parser: {
+    yy: {}
+  }
+
+  Parser.prototype: {
+    yy: {},
+    trace: function(),
+    symbols_: {associative list: name ==> number},
+    terminals_: {associative list: number ==> name},
+    productions_: [...],
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
+    table: [...],
+    defaultActions: {...},
+    parseError: function(str, hash),
+    parse: function(input),
+
+    lexer: {
+        EOF: 1,
+        parseError: function(str, hash),
+        setInput: function(input),
+        input: function(),
+        unput: function(str),
+        more: function(),
+        less: function(n),
+        pastInput: function(),
+        upcomingInput: function(),
+        showPosition: function(),
+        test_match: function(regex_match_array, rule_index),
+        next: function(),
+        lex: function(),
+        begin: function(condition),
+        popState: function(),
+        _currentRules: function(),
+        topState: function(),
+        pushState: function(condition),
+
+        options: {
+            ranges: boolean           (optional: true ==> token location info will include a .range[] member)
+            flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
+            backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
+        },
+
+        performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
+        rules: [...],
+        conditions: {associative list: name ==> set},
+    }
+  }
+
+
+  token location info (@$, _$, etc.): {
+    first_line: n,
+    last_line: n,
+    first_column: n,
+    last_column: n,
+    range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
+  }
+
+
+  the parseError function receives a 'hash' object with these members for lexer and parser errors: {
+    text:        (matched text)
+    token:       (the produced terminal token, if any)
+    line:        (yylineno)
+  }
+  while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
+    loc:         (yylloc)
+    expected:    (string describing the set of expected tokens)
+    recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
+  }
+*/
+var parser = (function () {
+    var o = function (k, v, o, l) { for (o = o || {}, l = k.length; l--; o[k[l]] = v)
+        ; return o; }, $V0 = [1, 19], $V1 = [1, 5], $V2 = [1, 6], $V3 = [1, 7], $V4 = [1, 8], $V5 = [1, 9], $V6 = [1, 10], $V7 = [1, 11], $V8 = [1, 12], $V9 = [1, 13], $Va = [1, 17], $Vb = [1, 14], $Vc = [1, 16], $Vd = [1, 20], $Ve = [4, 7], $Vf = [1, 23], $Vg = [1, 24], $Vh = [1, 25], $Vi = [1, 26], $Vj = [1, 27], $Vk = [1, 28], $Vl = [1, 29], $Vm = [1, 30], $Vn = [1, 31], $Vo = [1, 32], $Vp = [1, 33], $Vq = [1, 34], $Vr = [1, 35], $Vs = [1, 36], $Vt = [1, 37], $Vu = [1, 38], $Vv = [1, 39], $Vw = [1, 40], $Vx = [1, 41], $Vy = [1, 42], $Vz = [1, 43], $VA = [1, 44], $VB = [4, 7, 9, 12, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46, 48, 49, 50, 55, 56, 58, 60], $VC = [9, 12], $VD = [2, 6], $VE = [1, 82], $VF = [4, 7, 9, 12, 22, 23, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46, 48, 49, 50, 55, 56, 58, 60], $VG = [4, 7, 9, 12, 22, 23, 24, 25, 26, 28, 29, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46, 48, 49, 50, 55, 56, 58, 60], $VH = [4, 7, 9, 12, 28, 29, 31, 32, 46, 50, 55, 56, 58, 60], $VI = [1, 91], $VJ = [9, 46], $VK = [55, 58, 60];
+    var parser = { trace: function trace() { },
+        yy: {},
+        symbols_: { "error": 2, "program": 3, "EOF": 4, "expressions": 5, "e": 6, "NEWLINE": 7, "args": 8, ",": 9, "list_expr": 10, "(": 11, ")": 12, "TRUE": 13, "FALSE": 14, "NULL": 15, "NUMBER": 16, "DURATION": 17, "DURATION_PLACEHOLDER": 18, "STRING": 19, "COL": 20, "$SCOPE": 21, "+": 22, "-": 23, "*": 24, "/": 25, "%": 26, "^": 27, "|": 28, "&": 29, "!": 30, "?": 31, ":": 32, "case_when": 33, "=": 34, "!=": 35, "<": 36, "<=": 37, ">": 38, ">=": 39, "STARTS_WITH": 40, "ENDS_WITH": 41, "CONTAINS": 42, "NOT_CONTAINS": 43, "FUNCTION": 44, "{": 45, "}": 46, "agg_body": 47, "IN": 48, "NOT_IN": 49, "WHERE": 50, "agg_items": 51, "agg_where": 52, "case_expression_value": 53, "when_then_list": 54, "WHEN": 55, "THEN": 56, "case_when_else": 57, "ELSE": 58, "CASE": 59, "END": 60, "$accept": 0, "$end": 1 },
+        terminals_: { 2: "error", 4: "EOF", 7: "NEWLINE", 9: ",", 11: "(", 12: ")", 13: "TRUE", 14: "FALSE", 15: "NULL", 16: "NUMBER", 17: "DURATION", 18: "DURATION_PLACEHOLDER", 19: "STRING", 20: "COL", 21: "$SCOPE", 22: "+", 23: "-", 24: "*", 25: "/", 26: "%", 27: "^", 28: "|", 29: "&", 30: "!", 31: "?", 32: ":", 34: "=", 35: "!=", 36: "<", 37: "<=", 38: ">", 39: ">=", 40: "STARTS_WITH", 41: "ENDS_WITH", 42: "CONTAINS", 43: "NOT_CONTAINS", 44: "FUNCTION", 45: "{", 46: "}", 48: "IN", 49: "NOT_IN", 50: "WHERE", 55: "WHEN", 56: "THEN", 58: "ELSE", 59: "CASE", 60: "END" },
+        productions_: [0, [3, 1], [3, 2], [5, 1], [5, 2], [5, 3], [8, 0], [8, 1], [8, 3], [10, 5], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 2], [6, 5], [6, 1], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 3], [6, 4], [6, 3], [6, 4], [6, 2], [6, 5], [6, 5], [6, 1], [6, 3], [6, 3], [47, 1], [47, 2], [47, 3], [47, 1], [51, 1], [51, 3], [52, 2], [53, 0], [53, 1], [54, 4], [54, 5], [57, 0], [57, 2], [33, 5]],
+        performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
+            /* this == yyval */
+            var $0 = $$.length - 1;
+            switch (yystate) {
+                case 1:
+                    return [];
+                    break;
+                case 2:
+                    return $$[$0 - 1];
+                    break;
+                case 3:
+                case 7:
+                case 52:
+                case 53:
+                    this.$ = [$$[$0]];
+                    break;
+                case 4:
+                case 47:
+                    this.$ = $$[$0 - 1];
+                    break;
+                case 5:
+                case 8:
+                case 51:
+                case 54:
+                    this.$ = $$[$0 - 2].concat([$$[$0]]);
+                    break;
+                case 6:
+                    this.$ = [];
+                    break;
+                case 9:
+                    this.$ = yy.node('TO_ARRAY', [$$[$0 - 3]].concat($$[$0 - 1]), this._$, 'FUNCTION');
+                    break;
+                case 10:
+                    this.$ = true;
+                    break;
+                case 11:
+                    this.$ = false;
+                    break;
+                case 12:
+                    this.$ = null;
+                    break;
+                case 13:
+                    this.$ = Number($$[$0]);
+                    break;
+                case 14:
+                    this.$ = yy.durationNode($$[$0], this._$);
+                    break;
+                case 15:
+                    this.$ = yy.node('DURATION_PLACEHOLDER', [], this._$, 'VALUE_REF');
+                    break;
+                case 16:
+                    this.$ = yy.stringValue($$[$0]);
+                    break;
+                case 17:
+                    this.$ = yy.node('COL', [$$[$0].slice(1, -1)], this._$, 'VALUE_REF');
+                    break;
+                case 18:
+                    this.$ = yy.node('$SCOPE', [], this._$, 'VALUE_REF');
+                    break;
+                case 19:
+                    this.$ = yy.node('SUM', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 20:
+                    this.$ = yy.node('SUB', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 21:
+                    this.$ = yy.node('PRODUCT', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 22:
+                    this.$ = yy.node('DIV', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 23:
+                    this.$ = yy.node('MOD', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 24:
+                    this.$ = yy.node('POW', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 25:
+                    this.$ = yy.node('OR', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 26:
+                    this.$ = yy.node('AND', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 27:
+                    this.$ = yy.node('NOT', [$$[$0]], this._$, 'UNARY');
+                    break;
+                case 28:
+                    this.$ = yy.node('IF', [$$[$0 - 4], $$[$0 - 2], $$[$0]], this._$, 'CONDITIONAL');
+                    break;
+                case 29:
+                case 57:
+                case 61:
+                    this.$ = $$[$0];
+                    break;
+                case 30:
+                    this.$ = yy.node('EQ', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 31:
+                    this.$ = yy.node('NEQ', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 32:
+                    this.$ = yy.node('LT', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 33:
+                    this.$ = yy.node('LTE', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 34:
+                    this.$ = yy.node('GT', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 35:
+                    this.$ = yy.node('GTE', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 36:
+                    this.$ = yy.node('STARTS_WITH', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 37:
+                    this.$ = yy.node('ENDS_WITH', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 38:
+                    this.$ = yy.node('CONTAINS', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 39:
+                    this.$ = yy.node('NOT_CONTAINS', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 40:
+                    this.$ = yy.node($$[$0 - 3].toUpperCase(), $$[$0 - 1], this._$, 'FUNCTION');
+                    break;
+                case 41:
+                    this.$ = yy.node($$[$0 - 2].toUpperCase(), [], this._$, 'AGG_CALL');
+                    break;
+                case 42:
+                    this.$ = yy.node($$[$0 - 3].toUpperCase(), $$[$0 - 1], this._$, 'AGG_CALL');
+                    break;
+                case 43:
+                    this.$ = -$$[$0];
+                    break;
+                case 44:
+                    this.$ = yy.node('IN', [$$[$0 - 4], $$[$0 - 1]], this._$, 'INFIX');
+                    break;
+                case 45:
+                    this.$ = yy.node('NOT_IN', [$$[$0 - 4], $$[$0 - 1]], this._$, 'INFIX');
+                    break;
+                case 46:
+                case 49:
+                    this.$ = $$[$0];
+                    break;
+                case 48:
+                    this.$ = yy.node('WHERE', [$$[$0 - 2], $$[$0]], this._$, 'INFIX');
+                    break;
+                case 50:
+                    this.$ = $$[$0 - 1].concat([$$[$0]]);
+                    break;
+                case 55:
+                    this.$ = yy.node('WHERE', [$$[$0]], this._$, 'CLAUSE');
+                    break;
+                case 56:
+                case 60:
+                    this.$ = null;
+                    break;
+                case 58:
+                    this.$ = [{ WHEN: $$[$0 - 2], THEN: $$[$0] }];
+                    break;
+                case 59:
+                    this.$ = $$[$0 - 4];
+                    this.$.push({ WHEN: $$[$0 - 2], THEN: $$[$0] });
+                    break;
+                case 62:
+                    this.$ = yy.node('CASE', [$$[$0 - 3], $$[$0 - 2], $$[$0 - 1]], this._$, 'CONDITIONAL');
+                    break;
+            }
+        },
+        table: [{ 3: 1, 4: [1, 2], 5: 3, 6: 4, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 1: [3] }, { 1: [2, 1] }, { 4: [1, 21], 7: [1, 22] }, o($Ve, [2, 3], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }), o($VB, [2, 10]), o($VB, [2, 11]), o($VB, [2, 12]), o($VB, [2, 13]), o($VB, [2, 14]), o($VB, [2, 15]), o($VB, [2, 16]), o($VB, [2, 17]), o($VB, [2, 18]), { 6: 45, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, o($VB, [2, 29]), { 11: [1, 46], 45: [1, 47] }, { 6: 48, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, o($VB, [2, 46]), { 6: 49, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 51, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 53: 50, 55: [2, 56], 59: $Vd }, { 1: [2, 2] }, o($Ve, [2, 4], { 33: 15, 10: 18, 6: 52, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 44: $Vc, 59: $Vd }), { 6: 53, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 54, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 55, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 56, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 57, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 58, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 59, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 60, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 61, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 62, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 63, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 64, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 65, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 66, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 67, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 68, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 69, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 70, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 71, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 11: [1, 72] }, { 11: [1, 73] }, { 6: 74, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, o($VB, [2, 27]), o($VC, $VD, { 33: 15, 10: 18, 8: 75, 6: 76, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 44: $Vc, 59: $Vd }), { 6: 81, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 46: [1, 77], 47: 78, 50: $VE, 51: 79, 52: 80, 59: $Vd }, o($VB, [2, 43]), { 9: [1, 84], 12: [1, 83], 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }, { 54: 85, 55: [1, 86] }, { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA, 55: [2, 57] }, o($Ve, [2, 5], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }), o($VF, [2, 19], { 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VF, [2, 20], { 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VG, [2, 21], { 27: $Vk }), o($VG, [2, 22], { 27: $Vk }), o($VG, [2, 23], { 27: $Vk }), o($VB, [2, 24]), o([4, 7, 9, 12, 28, 31, 32, 46, 50, 55, 56, 58, 60], [2, 25], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 29: $Vm, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz }), o($VH, [2, 26], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz }), { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 32: [1, 87], 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }, o($VH, [2, 30], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VH, [2, 31], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VH, [2, 32], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VH, [2, 33], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VH, [2, 34], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VH, [2, 35], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VH, [2, 36], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VH, [2, 37], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VH, [2, 38], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VH, [2, 39], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk }), o($VC, $VD, { 33: 15, 10: 18, 6: 76, 8: 88, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 44: $Vc, 59: $Vd }), o($VC, $VD, { 33: 15, 10: 18, 6: 76, 8: 89, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 44: $Vc, 59: $Vd }), o([4, 7, 9, 12, 31, 32, 46, 50, 55, 56, 58, 60], [2, 48], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz }), { 9: $VI, 12: [1, 90] }, o($VC, [2, 7], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }), o($VB, [2, 41]), { 46: [1, 92] }, { 9: [1, 94], 46: [2, 49], 50: $VE, 52: 93 }, { 46: [2, 52] }, o($VJ, [2, 53], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }), { 6: 95, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, o($VB, [2, 47]), o($VC, $VD, { 33: 15, 10: 18, 6: 76, 8: 96, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 44: $Vc, 59: $Vd }), { 55: [1, 98], 57: 97, 58: [1, 99], 60: [2, 60] }, { 6: 100, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 101, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 9: $VI, 12: [1, 102] }, { 9: $VI, 12: [1, 103] }, o($VB, [2, 40]), { 6: 104, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, o($VB, [2, 42]), { 46: [2, 50] }, { 6: 106, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 50: $VE, 52: 105, 59: $Vd }, { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 46: [2, 55], 48: $Vy, 49: $Vz, 50: $VA }, { 9: $VI, 12: [1, 107] }, { 60: [1, 108] }, { 6: 109, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 110, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA, 56: [1, 111] }, o([4, 7, 9, 12, 32, 46, 55, 56, 58, 60], [2, 28], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }), o($VB, [2, 44]), o($VB, [2, 45]), o($VC, [2, 8], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }), { 46: [2, 51] }, o($VJ, [2, 54], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }), o($VB, [2, 9]), o($VB, [2, 62]), { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA, 56: [1, 112] }, { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA, 60: [2, 61] }, { 6: 113, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, { 6: 114, 10: 18, 11: $V0, 13: $V1, 14: $V2, 15: $V3, 16: $V4, 17: $V5, 18: $V6, 19: $V7, 20: $V8, 21: $V9, 23: $Va, 30: $Vb, 33: 15, 44: $Vc, 59: $Vd }, o($VK, [2, 58], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA }), o($VK, [2, 59], { 22: $Vf, 23: $Vg, 24: $Vh, 25: $Vi, 26: $Vj, 27: $Vk, 28: $Vl, 29: $Vm, 31: $Vn, 34: $Vo, 35: $Vp, 36: $Vq, 37: $Vr, 38: $Vs, 39: $Vt, 40: $Vu, 41: $Vv, 42: $Vw, 43: $Vx, 48: $Vy, 49: $Vz, 50: $VA })],
+        defaultActions: { 2: [2, 1], 21: [2, 2], 80: [2, 52], 93: [2, 50], 105: [2, 51] },
+        parseError: function parseError(str, hash) {
+            if (hash.recoverable) {
+                this.trace(str);
+            }
+            else {
+                var error = new Error(str);
+                error.hash = hash;
+                throw error;
+            }
+        },
+        parse: function parse(input) {
+            var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+            var args = lstack.slice.call(arguments, 1);
+            var lexer = Object.create(this.lexer);
+            var sharedState = { yy: {} };
+            for (var k in this.yy) {
+                if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
+                    sharedState.yy[k] = this.yy[k];
+                }
+            }
+            lexer.setInput(input, sharedState.yy);
+            sharedState.yy.lexer = lexer;
+            sharedState.yy.parser = this;
+            if (typeof lexer.yylloc == 'undefined') {
+                lexer.yylloc = {};
+            }
+            var yyloc = lexer.yylloc;
+            lstack.push(yyloc);
+            var ranges = lexer.options && lexer.options.ranges;
+            if (typeof sharedState.yy.parseError === 'function') {
+                this.parseError = sharedState.yy.parseError;
+            }
+            else {
+                this.parseError = Object.getPrototypeOf(this).parseError;
+            }
+            function popStack(n) {
+                stack.length = stack.length - 2 * n;
+                vstack.length = vstack.length - n;
+                lstack.length = lstack.length - n;
+            }
+            _token_stack: var lex = function () {
+                var token;
+                token = lexer.lex() || EOF;
+                if (typeof token !== 'number') {
+                    token = self.symbols_[token] || token;
+                }
+                return token;
+            };
+            var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
+            while (true) {
+                state = stack[stack.length - 1];
+                if (this.defaultActions[state]) {
+                    action = this.defaultActions[state];
+                }
+                else {
+                    if (symbol === null || typeof symbol == 'undefined') {
+                        symbol = lex();
+                    }
+                    action = table[state] && table[state][symbol];
+                }
+                if (typeof action === 'undefined' || !action.length || !action[0]) {
+                    var errStr = '';
+                    expected = [];
+                    for (p in table[state]) {
+                        if (this.terminals_[p] && p > TERROR) {
+                            expected.push('\'' + this.terminals_[p] + '\'');
+                        }
+                    }
+                    if (lexer.showPosition) {
+                        errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
+                    }
+                    else {
+                        errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
+                    }
+                    this.parseError(errStr, {
+                        text: lexer.match,
+                        token: this.terminals_[symbol] || symbol,
+                        line: lexer.yylineno,
+                        loc: yyloc,
+                        expected: expected
+                    });
+                }
+                if (action[0] instanceof Array && action.length > 1) {
+                    throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
+                }
+                switch (action[0]) {
+                    case 1:
+                        stack.push(symbol);
+                        vstack.push(lexer.yytext);
+                        lstack.push(lexer.yylloc);
+                        stack.push(action[1]);
+                        symbol = null;
+                        if (!preErrorSymbol) {
+                            yyleng = lexer.yyleng;
+                            yytext = lexer.yytext;
+                            yylineno = lexer.yylineno;
+                            yyloc = lexer.yylloc;
+                            if (recovering > 0) {
+                                recovering--;
+                            }
+                        }
+                        else {
+                            symbol = preErrorSymbol;
+                            preErrorSymbol = null;
+                        }
+                        break;
+                    case 2:
+                        len = this.productions_[action[1]][1];
+                        yyval.$ = vstack[vstack.length - len];
+                        yyval._$ = {
+                            first_line: lstack[lstack.length - (len || 1)].first_line,
+                            last_line: lstack[lstack.length - 1].last_line,
+                            first_column: lstack[lstack.length - (len || 1)].first_column,
+                            last_column: lstack[lstack.length - 1].last_column
+                        };
+                        if (ranges) {
+                            yyval._$.range = [
+                                lstack[lstack.length - (len || 1)].range[0],
+                                lstack[lstack.length - 1].range[1]
+                            ];
+                        }
+                        r = this.performAction.apply(yyval, [
+                            yytext,
+                            yyleng,
+                            yylineno,
+                            sharedState.yy,
+                            action[1],
+                            vstack,
+                            lstack
+                        ].concat(args));
+                        if (typeof r !== 'undefined') {
+                            return r;
+                        }
+                        if (len) {
+                            stack = stack.slice(0, -1 * len * 2);
+                            vstack = vstack.slice(0, -1 * len);
+                            lstack = lstack.slice(0, -1 * len);
+                        }
+                        stack.push(this.productions_[action[1]][0]);
+                        vstack.push(yyval.$);
+                        lstack.push(yyval._$);
+                        newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+                        stack.push(newState);
+                        break;
+                    case 3:
+                        return true;
+                }
+            }
+            return true;
+        } };
+    /* generated by jison-lex 0.3.4 */
+    var lexer = (function () {
+        var lexer = ({
+            EOF: 1,
+            parseError: function parseError(str, hash) {
+                if (this.yy.parser) {
+                    this.yy.parser.parseError(str, hash);
+                }
+                else {
+                    throw new Error(str);
+                }
+            },
+            // resets the lexer, sets new input
+            setInput: function (input, yy) {
+                this.yy = yy || this.yy || {};
+                this._input = input;
+                this._more = this._backtrack = this.done = false;
+                this.yylineno = this.yyleng = 0;
+                this.yytext = this.matched = this.match = '';
+                this.conditionStack = ['INITIAL'];
+                this.yylloc = {
+                    first_line: 1,
+                    first_column: 0,
+                    last_line: 1,
+                    last_column: 0
+                };
+                if (this.options.ranges) {
+                    this.yylloc.range = [0, 0];
+                }
+                this.offset = 0;
+                return this;
+            },
+            // consumes and returns one char from the input
+            input: function () {
+                var ch = this._input[0];
+                this.yytext += ch;
+                this.yyleng++;
+                this.offset++;
+                this.match += ch;
+                this.matched += ch;
+                var lines = ch.match(/(?:\r\n?|\n).*/g);
+                if (lines) {
+                    this.yylineno++;
+                    this.yylloc.last_line++;
+                }
+                else {
+                    this.yylloc.last_column++;
+                }
+                if (this.options.ranges) {
+                    this.yylloc.range[1]++;
+                }
+                this._input = this._input.slice(1);
+                return ch;
+            },
+            // unshifts one char (or a string) into the input
+            unput: function (ch) {
+                var len = ch.length;
+                var lines = ch.split(/(?:\r\n?|\n)/g);
+                this._input = ch + this._input;
+                this.yytext = this.yytext.substr(0, this.yytext.length - len);
+                //this.yyleng -= len;
+                this.offset -= len;
+                var oldLines = this.match.split(/(?:\r\n?|\n)/g);
+                this.match = this.match.substr(0, this.match.length - 1);
+                this.matched = this.matched.substr(0, this.matched.length - 1);
+                if (lines.length - 1) {
+                    this.yylineno -= lines.length - 1;
+                }
+                var r = this.yylloc.range;
+                this.yylloc = {
+                    first_line: this.yylloc.first_line,
+                    last_line: this.yylineno + 1,
+                    first_column: this.yylloc.first_column,
+                    last_column: lines ?
+                        (lines.length === oldLines.length ? this.yylloc.first_column : 0)
+                            + oldLines[oldLines.length - lines.length].length - lines[0].length :
+                        this.yylloc.first_column - len
+                };
+                if (this.options.ranges) {
+                    this.yylloc.range = [r[0], r[0] + this.yyleng - len];
+                }
+                this.yyleng = this.yytext.length;
+                return this;
+            },
+            // When called from action, caches matched text and appends it on next action
+            more: function () {
+                this._more = true;
+                return this;
+            },
+            // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+            reject: function () {
+                if (this.options.backtrack_lexer) {
+                    this._backtrack = true;
+                }
+                else {
+                    return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
+                        text: "",
+                        token: null,
+                        line: this.yylineno
+                    });
+                }
+                return this;
+            },
+            // retain first n characters of the match
+            less: function (n) {
+                this.unput(this.match.slice(n));
+            },
+            // displays already matched input, i.e. for error messages
+            pastInput: function () {
+                var past = this.matched.substr(0, this.matched.length - this.match.length);
+                return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
+            },
+            // displays upcoming input, i.e. for error messages
+            upcomingInput: function () {
+                var next = this.match;
+                if (next.length < 20) {
+                    next += this._input.substr(0, 20 - next.length);
+                }
+                return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
+            },
+            // displays the character position where the lexing error occurred, i.e. for error messages
+            showPosition: function () {
+                var pre = this.pastInput();
+                var c = new Array(pre.length + 1).join("-");
+                return pre + this.upcomingInput() + "\n" + c + "^";
+            },
+            // test the lexed token: return FALSE when not a match, otherwise return token
+            test_match: function (match, indexed_rule) {
+                var token, lines, backup;
+                if (this.options.backtrack_lexer) {
+                    // save context
+                    backup = {
+                        yylineno: this.yylineno,
+                        yylloc: {
+                            first_line: this.yylloc.first_line,
+                            last_line: this.last_line,
+                            first_column: this.yylloc.first_column,
+                            last_column: this.yylloc.last_column
+                        },
+                        yytext: this.yytext,
+                        match: this.match,
+                        matches: this.matches,
+                        matched: this.matched,
+                        yyleng: this.yyleng,
+                        offset: this.offset,
+                        _more: this._more,
+                        _input: this._input,
+                        yy: this.yy,
+                        conditionStack: this.conditionStack.slice(0),
+                        done: this.done
+                    };
+                    if (this.options.ranges) {
+                        backup.yylloc.range = this.yylloc.range.slice(0);
+                    }
+                }
+                lines = match[0].match(/(?:\r\n?|\n).*/g);
+                if (lines) {
+                    this.yylineno += lines.length;
+                }
+                this.yylloc = {
+                    first_line: this.yylloc.last_line,
+                    last_line: this.yylineno + 1,
+                    first_column: this.yylloc.last_column,
+                    last_column: lines ?
+                        lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
+                        this.yylloc.last_column + match[0].length
+                };
+                this.yytext += match[0];
+                this.match += match[0];
+                this.matches = match;
+                this.yyleng = this.yytext.length;
+                if (this.options.ranges) {
+                    this.yylloc.range = [this.offset, this.offset += this.yyleng];
+                }
+                this._more = false;
+                this._backtrack = false;
+                this._input = this._input.slice(match[0].length);
+                this.matched += match[0];
+                token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
+                if (this.done && this._input) {
+                    this.done = false;
+                }
+                if (token) {
+                    return token;
+                }
+                else if (this._backtrack) {
+                    // recover context
+                    for (var k in backup) {
+                        this[k] = backup[k];
+                    }
+                    return false; // rule action called reject() implying the next rule should be tested instead.
+                }
+                return false;
+            },
+            // return next match in input
+            next: function () {
+                if (this.done) {
+                    return this.EOF;
+                }
+                if (!this._input) {
+                    this.done = true;
+                }
+                var token, match, tempMatch, index;
+                if (!this._more) {
+                    this.yytext = '';
+                    this.match = '';
+                }
+                var rules = this._currentRules();
+                for (var i = 0; i < rules.length; i++) {
+                    tempMatch = this._input.match(this.rules[rules[i]]);
+                    if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+                        match = tempMatch;
+                        index = i;
+                        if (this.options.backtrack_lexer) {
+                            token = this.test_match(tempMatch, rules[i]);
+                            if (token !== false) {
+                                return token;
+                            }
+                            else if (this._backtrack) {
+                                match = false;
+                                continue; // rule action called reject() implying a rule MISmatch.
+                            }
+                            else {
+                                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
+                                return false;
+                            }
+                        }
+                        else if (!this.options.flex) {
+                            break;
+                        }
+                    }
+                }
+                if (match) {
+                    token = this.test_match(match, rules[index]);
+                    if (token !== false) {
+                        return token;
+                    }
+                    // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
+                    return false;
+                }
+                if (this._input === "") {
+                    return this.EOF;
+                }
+                else {
+                    return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
+                        text: "",
+                        token: null,
+                        line: this.yylineno
+                    });
+                }
+            },
+            // return next match that has a token
+            lex: function lex() {
+                var r = this.next();
+                if (r) {
+                    return r;
+                }
+                else {
+                    return this.lex();
+                }
+            },
+            // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+            begin: function begin(condition) {
+                this.conditionStack.push(condition);
+            },
+            // pop the previously active lexer condition state off the condition stack
+            popState: function popState() {
+                var n = this.conditionStack.length - 1;
+                if (n > 0) {
+                    return this.conditionStack.pop();
+                }
+                else {
+                    return this.conditionStack[0];
+                }
+            },
+            // produce the lexer rule set which is active for the currently active lexer condition state
+            _currentRules: function _currentRules() {
+                if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
+                    return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
+                }
+                else {
+                    return this.conditions["INITIAL"].rules;
+                }
+            },
+            // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+            topState: function topState(n) {
+                n = this.conditionStack.length - 1 - Math.abs(n || 0);
+                if (n >= 0) {
+                    return this.conditionStack[n];
+                }
+                else {
+                    return "INITIAL";
+                }
+            },
+            // alias for begin(condition)
+            pushState: function pushState(condition) {
+                this.begin(condition);
+            },
+            // return the number of states currently on the stack
+            stateStackSize: function stateStackSize() {
+                return this.conditionStack.length;
+            },
+            options: { "ranges": true, "case-insensitive": true },
+            performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
+                /*
+                 * `kind` is the structural discriminator of AST contract v2; `metaInfo` is
+                 * its contract-v1 name, kept in sync for consumers that still read it
+                 * (removed at contract v3).
+                 */
+                yy.node = function (type, args, location, kind) {
+                    return {
+                        type,
+                        args,
+                        range: location.range,
+                        kind,
+                        metaInfo: kind
+                    };
+                };
+                /*
+                 * Duration literal ('5m', '250ms', …) → typed node. args = [msValue,
+                 * unit]: the value normalized to milliseconds plus the authored unit (so
+                 * the canonical printer can reproduce the source spelling). Grain: ms, s,
+                 * m (minutes — never months), h, d.
+                 */
+                yy.durationNode = function (text, location) {
+                    var match = /^([0-9]+)(ms|s|m|h|d)$/i.exec(text);
+                    var unit = match[2].toLowerCase();
+                    var factor = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 }[unit];
+                    return yy.node('DURATION', [Number(match[1]) * factor, unit], location, 'VALUE_REF');
+                };
+                /*
+                 * Strings embed their own quote by doubling it ('O''Brien',
+                 * "say ""hi"""). Undo the doubling of the delimiter quote only.
+                 */
+                yy.stringValue = function (text) {
+                    var quote = text[0];
+                    return text.slice(1, -1).split(quote + quote).join(quote);
+                };
+                /*
+                 * Newlines are insignificant inside brackets. The bracket rules below
+                 * maintain a depth counter on `yy`; the NEWLINE rule only emits a token at
+                 * depth 0. `yy` outlives a single parse (jison shares it across calls), so
+                 * the counter is reset at the first scanned token of each input — and only
+                 * there, `matched` (all consumed text) equals `match` (current text).
+                 */
+                if (this.matched === this.match) {
+                    yy.bracketDepth = 0;
+                }
+                var YYSTATE = YY_START;
+                switch ($avoiding_name_collisions) {
+                    case 0:
+                        if (!yy.bracketDepth)
+                            return 7;
+                        break;
+                    case 1: /* skip whitespace */
+                        break;
+                    case 2:
+                        return 17;
+                        break;
+                    case 3:
+                        return 18;
+                        break;
+                    case 4:
+                        return 16;
+                        break;
+                    case 5:
+                        return 19;
+                        break;
+                    case 6:
+                        return 44;
+                        break;
+                    case 7:
+                        return 21;
+                        break;
+                    case 8:
+                        return 20;
+                        break;
+                    case 9:
+                        return 15;
+                        break;
+                    case 10:
+                        return 35;
+                        break;
+                    case 11:
+                        return 39;
+                        break;
+                    case 12:
+                        return 37;
+                        break;
+                    case 13:
+                        return 34;
+                        break;
+                    case 14:
+                        return 38;
+                        break;
+                    case 15:
+                        return 36;
+                        break;
+                    case 16:
+                        return 40;
+                        break;
+                    case 17:
+                        return 41;
+                        break;
+                    case 18:
+                        return 42;
+                        break;
+                    case 19:
+                        return 43;
+                        break;
+                    case 20:
+                        return 49;
+                        break;
+                    case 21:
+                        return 30;
+                        break;
+                    case 22:
+                        return 29;
+                        break;
+                    case 23:
+                        return 28;
+                        break;
+                    case 24:
+                        return 50;
+                        break;
+                    case 25:
+                        return 48;
+                        break;
+                    case 26:
+                        return 59;
+                        break;
+                    case 27:
+                        return 55;
+                        break;
+                    case 28:
+                        return 56;
+                        break;
+                    case 29:
+                        return 58;
+                        break;
+                    case 30:
+                        return 60;
+                        break;
+                    case 31:
+                        return 24;
+                        break;
+                    case 32:
+                        return 25;
+                        break;
+                    case 33:
+                        return 23;
+                        break;
+                    case 34:
+                        return 22;
+                        break;
+                    case 35:
+                        return 26;
+                        break;
+                    case 36:
+                        return 27;
+                        break;
+                    case 37:
+                        yy.bracketDepth = (yy.bracketDepth || 0) + 1;
+                        return 11;
+                        break;
+                    case 38:
+                        if (yy.bracketDepth) {
+                            yy.bracketDepth--;
+                        }
+                        return 12;
+                        break;
+                    case 39:
+                        yy.bracketDepth = (yy.bracketDepth || 0) + 1;
+                        return 45;
+                        break;
+                    case 40:
+                        if (yy.bracketDepth) {
+                            yy.bracketDepth--;
+                        }
+                        return 46;
+                        break;
+                    case 41:
+                        yy.bracketDepth = (yy.bracketDepth || 0) + 1;
+                        return '[';
+                        break;
+                    case 42:
+                        if (yy.bracketDepth) {
+                            yy.bracketDepth--;
+                        }
+                        return ']';
+                        break;
+                    case 43:
+                        return 9;
+                        break;
+                    case 44:
+                        return 31;
+                        break;
+                    case 45:
+                        return 32;
+                        break;
+                    case 46:
+                        return 13;
+                        break;
+                    case 47:
+                        return 14;
+                        break;
+                    case 48:
+                        return 4;
+                        break;
+                    case 49:
+                        return 'INVALID';
+                        break;
+                }
+            },
+            rules: [/^(?:(\r?\n)+\s*)/i, /^(?:[^\S\r?\n]+)/i, /^(?:[0-9]+(ms|s|m|h|d)\b)/i, /^(?:duration-here\b)/i, /^(?:[0-9]+(\.[0-9]+)?\b)/i, /^(?:"(""|[^"])*"|'(''|[^'])*')/i, /^(?:[$A-Za-z][A-Za-z_0-9\.]+(?=[({]))/i, /^(?:\$SCOPE\b)/i, /^(?:\[[^[]+\])/i, /^(?:NULL\b)/i, /^(?:!=)/i, /^(?:>=)/i, /^(?:<=)/i, /^(?:=)/i, /^(?:>)/i, /^(?:<)/i, /^(?:STARTS_WITH\b)/i, /^(?:ENDS_WITH\b)/i, /^(?:CONTAINS\b)/i, /^(?:NOT_CONTAINS\b)/i, /^(?:NOT_IN\b)/i, /^(?:!|NOT\b)/i, /^(?:&|AND\b)/i, /^(?:\||OR\b)/i, /^(?:WHERE\b)/i, /^(?:IN\b)/i, /^(?:CASE\b)/i, /^(?:WHEN\b)/i, /^(?:THEN\b)/i, /^(?:ELSE\b)/i, /^(?:END\b)/i, /^(?:\*)/i, /^(?:\/)/i, /^(?:-)/i, /^(?:\+)/i, /^(?:%)/i, /^(?:\^)/i, /^(?:\()/i, /^(?:\))/i, /^(?:\{)/i, /^(?:\})/i, /^(?:\[)/i, /^(?:\])/i, /^(?:,)/i, /^(?:\?)/i, /^(?::)/i, /^(?:TRUE\b)/i, /^(?:FALSE\b)/i, /^(?:$)/i, /^(?:.)/i],
+            conditions: { "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49], "inclusive": true } }
+        });
+        return lexer;
+    })();
+    parser.lexer = lexer;
+    function Parser() {
+        this.yy = {};
+    }
+    Parser.prototype = parser;
+    parser.Parser = Parser;
+    return new Parser;
+})();
+export default parser;
+//# sourceMappingURL=parser.js.map