@glimmer/syntax/dist/dev/index.cjs.map

{"version":3,"file":"index.cjs","sources":["../../../util/lib/object-utils.ts","../../../../../node_modules/.pnpm/@handlebars+parser@2.2.0/node_modules/@handlebars/parser/dist/esm/exception.js","../../../../../node_modules/.pnpm/@handlebars+parser@2.2.0/node_modules/@handlebars/parser/dist/esm/parser.js","../../../../../node_modules/.pnpm/simple-html-tokenizer@0.5.11/node_modules/simple-html-tokenizer/dist/es6/index.js","../../lib/source/loc/kinds.ts","../../lib/v2/objects/constants.ts"],"sourcesContent":["export const assign = Object.assign;\n\nexport function values<T>(obj: { [s: string]: T }): T[] {\n  return Object.values(obj);\n}\n\nexport type ObjectEntry<D extends object> = { [P in keyof D]: [P, D[P]] }[keyof D];\n\nexport function entries<D extends object>(dict: D): ObjectEntry<D>[] {\n  return Object.entries(dict) as ObjectEntry<D>[];\n}\n\nexport function keys<T extends object>(obj: T): (keyof T)[] {\n  return Object.keys(obj) as (keyof T)[];\n}\n","var errorProps = [\n    'description',\n    'fileName',\n    'lineNumber',\n    'endLineNumber',\n    'message',\n    'name',\n    'number',\n    'stack'\n];\nfunction Exception(message, node) {\n    var loc = node && node.loc, line, endLineNumber, column, endColumn;\n    if (loc) {\n        line = loc.start.line;\n        endLineNumber = loc.end.line;\n        column = loc.start.column;\n        endColumn = loc.end.column;\n        message += ' - ' + line + ':' + column;\n    }\n    var tmp = Error.prototype.constructor.call(this, message);\n    // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.\n    for (var idx = 0; idx < errorProps.length; idx++) {\n        this[errorProps[idx]] = tmp[errorProps[idx]];\n    }\n    /* istanbul ignore else */\n    if (Error.captureStackTrace) {\n        Error.captureStackTrace(this, Exception);\n    }\n    try {\n        if (loc) {\n            this.lineNumber = line;\n            this.endLineNumber = endLineNumber;\n            // Work around issue under safari where we can't directly set the column value\n            /* istanbul ignore next */\n            if (Object.defineProperty) {\n                Object.defineProperty(this, 'column', {\n                    value: column,\n                    enumerable: true\n                });\n                Object.defineProperty(this, 'endColumn', {\n                    value: endColumn,\n                    enumerable: true\n                });\n            }\n            else {\n                this.column = column;\n                this.endColumn = endColumn;\n            }\n        }\n    }\n    catch (nop) {\n        /* Ignore if the browser is very particular */\n    }\n}\nException.prototype = new Error();\nexport default Exception;\n//# sourceMappingURL=data:application/json;base64,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","/* parser generated by jison 0.4.18 */\n/*\n  Returns a Parser object of the following structure:\n\n  Parser: {\n    yy: {}\n  }\n\n  Parser.prototype: {\n    yy: {},\n    trace: function(),\n    symbols_: {associative list: name ==> number},\n    terminals_: {associative list: number ==> name},\n    productions_: [...],\n    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),\n    table: [...],\n    defaultActions: {...},\n    parseError: function(str, hash),\n    parse: function(input),\n\n    lexer: {\n        EOF: 1,\n        parseError: function(str, hash),\n        setInput: function(input),\n        input: function(),\n        unput: function(str),\n        more: function(),\n        less: function(n),\n        pastInput: function(),\n        upcomingInput: function(),\n        showPosition: function(),\n        test_match: function(regex_match_array, rule_index),\n        next: function(),\n        lex: function(),\n        begin: function(condition),\n        popState: function(),\n        _currentRules: function(),\n        topState: function(),\n        pushState: function(condition),\n\n        options: {\n            ranges: boolean           (optional: true ==> token location info will include a .range[] member)\n            flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)\n            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)\n        },\n\n        performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),\n        rules: [...],\n        conditions: {associative list: name ==> set},\n    }\n  }\n\n\n  token location info (@$, _$, etc.): {\n    first_line: n,\n    last_line: n,\n    first_column: n,\n    last_column: n,\n    range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)\n  }\n\n\n  the parseError function receives a 'hash' object with these members for lexer and parser errors: {\n    text:        (matched text)\n    token:       (the produced terminal token, if any)\n    line:        (yylineno)\n  }\n  while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {\n    loc:         (yylloc)\n    expected:    (string describing the set of expected tokens)\n    recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)\n  }\n*/\nvar parser = (function () {\n    var o = function (k, v, o, l) { for (o = o || {}, l = k.length; l--; o[k[l]] = v)\n        ; return o; }, $V0 = [2, 52], $V1 = [1, 20], $V2 = [5, 14, 15, 19, 29, 34, 39, 44, 47, 48, 53, 57, 61], $V3 = [1, 44], $V4 = [1, 40], $V5 = [1, 43], $V6 = [1, 33], $V7 = [1, 34], $V8 = [1, 35], $V9 = [1, 36], $Va = [1, 37], $Vb = [1, 42], $Vc = [1, 46], $Vd = [14, 15, 19, 29, 34, 39, 44, 47, 48, 53, 57, 61], $Ve = [14, 15, 19, 29, 34, 44, 47, 48, 53, 57, 61], $Vf = [15, 18], $Vg = [14, 15, 19, 29, 34, 47, 48, 53, 57, 61], $Vh = [33, 67, 73, 75, 84, 85, 86, 87, 88, 89], $Vi = [23, 33, 56, 67, 68, 73, 75, 77, 79, 84, 85, 86, 87, 88, 89], $Vj = [1, 62], $Vk = [1, 63], $Vl = [23, 33, 56, 68, 73, 79], $Vm = [23, 33, 56, 67, 68, 73, 75, 77, 79, 84, 85, 86, 87, 88, 89, 92, 93], $Vn = [2, 51], $Vo = [1, 64], $Vp = [67, 73, 75, 77, 84, 85, 86, 87, 88, 89], $Vq = [56, 67, 73, 75, 84, 85, 86, 87, 88, 89], $Vr = [1, 75], $Vs = [1, 76], $Vt = [1, 83], $Vu = [33, 67, 73, 75, 79, 84, 85, 86, 87, 88, 89], $Vv = [23, 67, 73, 75, 84, 85, 86, 87, 88, 89], $Vw = [67, 68, 73, 75, 84, 85, 86, 87, 88, 89], $Vx = [33, 79], $Vy = [1, 134], $Vz = [73, 81];\n    var parser = { trace: function trace() { },\n        yy: {},\n        symbols_: { \"error\": 2, \"root\": 3, \"program\": 4, \"EOF\": 5, \"program_repetition0\": 6, \"statement\": 7, \"mustache\": 8, \"block\": 9, \"rawBlock\": 10, \"partial\": 11, \"partialBlock\": 12, \"content\": 13, \"COMMENT\": 14, \"CONTENT\": 15, \"openRawBlock\": 16, \"rawBlock_repetition0\": 17, \"END_RAW_BLOCK\": 18, \"OPEN_RAW_BLOCK\": 19, \"helperName\": 20, \"openRawBlock_repetition0\": 21, \"openRawBlock_option0\": 22, \"CLOSE_RAW_BLOCK\": 23, \"openBlock\": 24, \"block_option0\": 25, \"closeBlock\": 26, \"openInverse\": 27, \"block_option1\": 28, \"OPEN_BLOCK\": 29, \"openBlock_repetition0\": 30, \"openBlock_option0\": 31, \"openBlock_option1\": 32, \"CLOSE\": 33, \"OPEN_INVERSE\": 34, \"openInverse_repetition0\": 35, \"openInverse_option0\": 36, \"openInverse_option1\": 37, \"openInverseChain\": 38, \"OPEN_INVERSE_CHAIN\": 39, \"openInverseChain_repetition0\": 40, \"openInverseChain_option0\": 41, \"openInverseChain_option1\": 42, \"inverseAndProgram\": 43, \"INVERSE\": 44, \"inverseChain\": 45, \"inverseChain_option0\": 46, \"OPEN_ENDBLOCK\": 47, \"OPEN\": 48, \"hash\": 49, \"expr\": 50, \"mustache_repetition0\": 51, \"mustache_option0\": 52, \"OPEN_UNESCAPED\": 53, \"mustache_repetition1\": 54, \"mustache_option1\": 55, \"CLOSE_UNESCAPED\": 56, \"OPEN_PARTIAL\": 57, \"partial_repetition0\": 58, \"partial_option0\": 59, \"openPartialBlock\": 60, \"OPEN_PARTIAL_BLOCK\": 61, \"openPartialBlock_repetition0\": 62, \"openPartialBlock_option0\": 63, \"exprHead\": 64, \"arrayLiteral\": 65, \"sexpr\": 66, \"OPEN_SEXPR\": 67, \"CLOSE_SEXPR\": 68, \"sexpr_repetition0\": 69, \"sexpr_option0\": 70, \"hash_repetition_plus0\": 71, \"hashSegment\": 72, \"ID\": 73, \"EQUALS\": 74, \"OPEN_ARRAY\": 75, \"arrayLiteral_repetition0\": 76, \"CLOSE_ARRAY\": 77, \"blockParams\": 78, \"OPEN_BLOCK_PARAMS\": 79, \"blockParams_repetition_plus0\": 80, \"CLOSE_BLOCK_PARAMS\": 81, \"path\": 82, \"dataName\": 83, \"STRING\": 84, \"NUMBER\": 85, \"BOOLEAN\": 86, \"UNDEFINED\": 87, \"NULL\": 88, \"DATA\": 89, \"pathSegments\": 90, \"sep\": 91, \"SEP\": 92, \"PRIVATE_SEP\": 93, \"$accept\": 0, \"$end\": 1 },\n        terminals_: { 2: \"error\", 5: \"EOF\", 14: \"COMMENT\", 15: \"CONTENT\", 18: \"END_RAW_BLOCK\", 19: \"OPEN_RAW_BLOCK\", 23: \"CLOSE_RAW_BLOCK\", 29: \"OPEN_BLOCK\", 33: \"CLOSE\", 34: \"OPEN_INVERSE\", 39: \"OPEN_INVERSE_CHAIN\", 44: \"INVERSE\", 47: \"OPEN_ENDBLOCK\", 48: \"OPEN\", 53: \"OPEN_UNESCAPED\", 56: \"CLOSE_UNESCAPED\", 57: \"OPEN_PARTIAL\", 61: \"OPEN_PARTIAL_BLOCK\", 67: \"OPEN_SEXPR\", 68: \"CLOSE_SEXPR\", 73: \"ID\", 74: \"EQUALS\", 75: \"OPEN_ARRAY\", 77: \"CLOSE_ARRAY\", 79: \"OPEN_BLOCK_PARAMS\", 81: \"CLOSE_BLOCK_PARAMS\", 84: \"STRING\", 85: \"NUMBER\", 86: \"BOOLEAN\", 87: \"UNDEFINED\", 88: \"NULL\", 89: \"DATA\", 92: \"SEP\", 93: \"PRIVATE_SEP\" },\n        productions_: [0, [3, 2], [4, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [13, 1], [10, 3], [16, 5], [9, 4], [9, 4], [24, 6], [27, 6], [38, 6], [43, 2], [45, 3], [45, 1], [26, 3], [8, 3], [8, 5], [8, 5], [11, 5], [12, 3], [60, 5], [50, 1], [50, 1], [64, 1], [64, 1], [66, 3], [66, 5], [49, 1], [72, 3], [65, 3], [78, 3], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [83, 2], [91, 1], [91, 1], [82, 3], [82, 1], [90, 3], [90, 1], [6, 0], [6, 2], [17, 0], [17, 2], [21, 0], [21, 2], [22, 0], [22, 1], [25, 0], [25, 1], [28, 0], [28, 1], [30, 0], [30, 2], [31, 0], [31, 1], [32, 0], [32, 1], [35, 0], [35, 2], [36, 0], [36, 1], [37, 0], [37, 1], [40, 0], [40, 2], [41, 0], [41, 1], [42, 0], [42, 1], [46, 0], [46, 1], [51, 0], [51, 2], [52, 0], [52, 1], [54, 0], [54, 2], [55, 0], [55, 1], [58, 0], [58, 2], [59, 0], [59, 1], [62, 0], [62, 2], [63, 0], [63, 1], [69, 0], [69, 2], [70, 0], [70, 1], [71, 1], [71, 2], [76, 0], [76, 2], [80, 1], [80, 2]],\n        performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {\n            /* this == yyval */\n            var $0 = $$.length - 1;\n            switch (yystate) {\n                case 1:\n                    return $$[$0 - 1];\n                    break;\n                case 2:\n                    this.$ = yy.prepareProgram($$[$0]);\n                    break;\n                case 3:\n                case 4:\n                case 5:\n                case 6:\n                case 7:\n                case 8:\n                case 20:\n                case 28:\n                case 29:\n                case 30:\n                case 31:\n                case 38:\n                case 39:\n                case 46:\n                case 47:\n                    this.$ = $$[$0];\n                    break;\n                case 9:\n                    this.$ = {\n                        type: 'CommentStatement',\n                        value: yy.stripComment($$[$0]),\n                        strip: yy.stripFlags($$[$0], $$[$0]),\n                        loc: yy.locInfo(this._$)\n                    };\n                    break;\n                case 10:\n                    this.$ = {\n                        type: 'ContentStatement',\n                        original: $$[$0],\n                        value: $$[$0],\n                        loc: yy.locInfo(this._$)\n                    };\n                    break;\n                case 11:\n                    this.$ = yy.prepareRawBlock($$[$0 - 2], $$[$0 - 1], $$[$0], this._$);\n                    break;\n                case 12:\n                    this.$ = { path: $$[$0 - 3], params: $$[$0 - 2], hash: $$[$0 - 1] };\n                    break;\n                case 13:\n                    this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], false, this._$);\n                    break;\n                case 14:\n                    this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], true, this._$);\n                    break;\n                case 15:\n                    this.$ = { open: $$[$0 - 5], path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) };\n                    break;\n                case 16:\n                case 17:\n                    this.$ = { path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) };\n                    break;\n                case 18:\n                    this.$ = { strip: yy.stripFlags($$[$0 - 1], $$[$0 - 1]), program: $$[$0] };\n                    break;\n                case 19:\n                    var inverse = yy.prepareBlock($$[$0 - 2], $$[$0 - 1], $$[$0], $$[$0], false, this._$), program = yy.prepareProgram([inverse], $$[$0 - 1].loc);\n                    program.chained = true;\n                    this.$ = { strip: $$[$0 - 2].strip, program: program, chain: true };\n                    break;\n                case 21:\n                    this.$ = { path: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 2], $$[$0]) };\n                    break;\n                case 22:\n                    this.$ = yy.prepareMustache(yy.syntax.hash($$[$0 - 1], yy.locInfo(this._$), { yy: yy, syntax: 'expr' }), [], undefined, $$[$0 - 2], yy.stripFlags($$[$0 - 2], $$[$0]), this._$);\n                    break;\n                case 23:\n                case 24:\n                    this.$ = yy.prepareMustache($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0 - 4], yy.stripFlags($$[$0 - 4], $$[$0]), this._$);\n                    break;\n                case 25:\n                    this.$ = {\n                        type: 'PartialStatement',\n                        name: $$[$0 - 3],\n                        params: $$[$0 - 2],\n                        hash: $$[$0 - 1],\n                        indent: '',\n                        strip: yy.stripFlags($$[$0 - 4], $$[$0]),\n                        loc: yy.locInfo(this._$)\n                    };\n                    break;\n                case 26:\n                    this.$ = yy.preparePartialBlock($$[$0 - 2], $$[$0 - 1], $$[$0], this._$);\n                    break;\n                case 27:\n                    this.$ = { path: $$[$0 - 3], params: $$[$0 - 2], hash: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 4], $$[$0]) };\n                    break;\n                case 32:\n                    this.$ = yy.syntax.hash($$[$0 - 1], yy.locInfo(this._$), { yy: yy, syntax: 'expr' });\n                    break;\n                case 33:\n                    this.$ = {\n                        type: 'SubExpression',\n                        path: $$[$0 - 3],\n                        params: $$[$0 - 2],\n                        hash: $$[$0 - 1],\n                        loc: yy.locInfo(this._$)\n                    };\n                    break;\n                case 34:\n                    this.$ = { type: 'Hash', pairs: $$[$0], loc: yy.locInfo(this._$) };\n                    break;\n                case 35:\n                    this.$ = { type: 'HashPair', key: yy.id($$[$0 - 2]), value: $$[$0], loc: yy.locInfo(this._$) };\n                    break;\n                case 36:\n                    this.$ = yy.syntax.square($$[$0 - 1], yy.locInfo(this._$), { yy: yy, syntax: 'expr' });\n                    break;\n                case 37:\n                    this.$ = yy.id($$[$0 - 1]);\n                    break;\n                case 40:\n                    this.$ = { type: 'StringLiteral', value: $$[$0], original: $$[$0], loc: yy.locInfo(this._$) };\n                    break;\n                case 41:\n                    this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };\n                    break;\n                case 42:\n                    this.$ = { type: 'BooleanLiteral', value: $$[$0] === 'true', original: $$[$0] === 'true', loc: yy.locInfo(this._$) };\n                    break;\n                case 43:\n                    this.$ = { type: 'UndefinedLiteral', original: undefined, value: undefined, loc: yy.locInfo(this._$) };\n                    break;\n                case 44:\n                    this.$ = { type: 'NullLiteral', original: null, value: null, loc: yy.locInfo(this._$) };\n                    break;\n                case 45:\n                    this.$ = yy.preparePath(true, false, $$[$0], this._$);\n                    break;\n                case 48:\n                    this.$ = yy.preparePath(false, $$[$0 - 2], $$[$0], this._$);\n                    break;\n                case 49:\n                    this.$ = yy.preparePath(false, false, $$[$0], this._$);\n                    break;\n                case 50:\n                    $$[$0 - 2].push({ part: yy.id($$[$0]), original: $$[$0], separator: $$[$0 - 1] });\n                    this.$ = $$[$0 - 2];\n                    break;\n                case 51:\n                    this.$ = [{ part: yy.id($$[$0]), original: $$[$0] }];\n                    break;\n                case 52:\n                case 54:\n                case 56:\n                case 64:\n                case 70:\n                case 76:\n                case 84:\n                case 88:\n                case 92:\n                case 96:\n                case 100:\n                case 106:\n                    this.$ = [];\n                    break;\n                case 53:\n                case 55:\n                case 57:\n                case 65:\n                case 71:\n                case 77:\n                case 85:\n                case 89:\n                case 93:\n                case 97:\n                case 101:\n                case 105:\n                case 107:\n                case 109:\n                    $$[$0 - 1].push($$[$0]);\n                    break;\n                case 104:\n                case 108:\n                    this.$ = [$$[$0]];\n                    break;\n            }\n        },\n        table: [o([5, 14, 15, 19, 29, 34, 48, 53, 57, 61], $V0, { 3: 1, 4: 2, 6: 3 }), { 1: [3] }, { 5: [1, 4] }, o([5, 39, 44, 47], [2, 2], { 7: 5, 8: 6, 9: 7, 10: 8, 11: 9, 12: 10, 13: 11, 24: 15, 27: 16, 16: 17, 60: 19, 14: [1, 12], 15: $V1, 19: [1, 23], 29: [1, 21], 34: [1, 22], 48: [1, 13], 53: [1, 14], 57: [1, 18], 61: [1, 24] }), { 1: [2, 1] }, o($V2, [2, 53]), o($V2, [2, 3]), o($V2, [2, 4]), o($V2, [2, 5]), o($V2, [2, 6]), o($V2, [2, 7]), o($V2, [2, 8]), o($V2, [2, 9]), { 20: 28, 49: 25, 50: 26, 64: 29, 65: 38, 66: 39, 67: $V3, 71: 27, 72: 30, 73: $V4, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 20: 28, 50: 45, 64: 29, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, o($Vd, $V0, { 6: 3, 4: 47 }), o($Ve, $V0, { 6: 3, 4: 48 }), o($Vf, [2, 54], { 17: 49 }), { 20: 28, 50: 50, 64: 29, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, o($Vg, $V0, { 6: 3, 4: 51 }), o([5, 14, 15, 18, 19, 29, 34, 39, 44, 47, 48, 53, 57, 61], [2, 10]), { 20: 52, 64: 53, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 20: 54, 64: 53, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 20: 55, 64: 53, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 20: 28, 50: 56, 64: 29, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 33: [1, 57] }, o($Vh, [2, 84], { 51: 58 }), o([23, 33, 56, 68, 79], [2, 34], { 72: 59, 73: [1, 60] }), o($Vi, [2, 28]), o($Vi, [2, 29], { 91: 61, 92: $Vj, 93: $Vk }), o($Vl, [2, 104]), o($Vi, [2, 38]), o($Vi, [2, 39]), o($Vi, [2, 40]), o($Vi, [2, 41]), o($Vi, [2, 42]), o($Vi, [2, 43]), o($Vi, [2, 44]), o($Vm, [2, 30]), o($Vm, [2, 31]), o([23, 33, 56, 67, 68, 73, 75, 79, 84, 85, 86, 87, 88, 89, 92, 93], $Vn, { 74: $Vo }), o($Vi, [2, 49], { 91: 65, 92: $Vj, 93: $Vk }), { 73: $Vc, 90: 66 }, o($Vp, [2, 106], { 76: 67 }), { 20: 28, 49: 68, 50: 69, 64: 29, 65: 38, 66: 39, 67: $V3, 71: 27, 72: 30, 73: $V4, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, o($Vq, [2, 88], { 54: 70 }), o($Vm, $Vn), { 25: 71, 38: 73, 39: $Vr, 43: 74, 44: $Vs, 45: 72, 47: [2, 60] }, { 28: 77, 43: 78, 44: $Vs, 47: [2, 62] }, { 13: 80, 15: $V1, 18: [1, 79] }, o($Vh, [2, 92], { 58: 81 }), { 26: 82, 47: $Vt }, o($Vu, [2, 64], { 30: 84 }), { 91: 61, 92: $Vj, 93: $Vk }, o($Vu, [2, 70], { 35: 85 }), o($Vv, [2, 56], { 21: 86 }), o($Vh, [2, 96], { 62: 87 }), o($V2, [2, 22]), { 20: 28, 33: [2, 86], 49: 90, 50: 89, 52: 88, 64: 29, 65: 38, 66: 39, 67: $V3, 71: 27, 72: 30, 73: $V4, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, o($Vl, [2, 105]), { 74: $Vo }, { 73: $Vc, 90: 91 }, { 73: [2, 46] }, { 73: [2, 47] }, { 20: 28, 50: 92, 64: 29, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 73: [1, 93] }, o($Vi, [2, 45], { 91: 65, 92: $Vj, 93: $Vk }), { 20: 28, 50: 95, 64: 29, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 77: [1, 94], 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 68: [1, 96] }, o($Vw, [2, 100], { 69: 97 }), { 20: 28, 49: 100, 50: 99, 55: 98, 56: [2, 90], 64: 29, 65: 38, 66: 39, 67: $V3, 71: 27, 72: 30, 73: $V4, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 26: 101, 47: $Vt }, { 47: [2, 61] }, o($Vd, $V0, { 6: 3, 4: 102 }), { 47: [2, 20] }, { 20: 103, 64: 53, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, o($Vg, $V0, { 6: 3, 4: 104 }), { 26: 105, 47: $Vt }, { 47: [2, 63] }, o($V2, [2, 11]), o($Vf, [2, 55]), { 20: 28, 33: [2, 94], 49: 108, 50: 107, 59: 106, 64: 29, 65: 38, 66: 39, 67: $V3, 71: 27, 72: 30, 73: $V4, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, o($V2, [2, 26]), { 20: 109, 64: 53, 65: 38, 66: 39, 67: $V3, 73: $Vc, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, o($Vx, [2, 66], { 71: 27, 20: 28, 64: 29, 72: 30, 82: 31, 83: 32, 65: 38, 66: 39, 90: 41, 31: 110, 50: 111, 49: 112, 67: $V3, 73: $V4, 75: $V5, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb }), o($Vx, [2, 72], { 71: 27, 20: 28, 64: 29, 72: 30, 82: 31, 83: 32, 65: 38, 66: 39, 90: 41, 36: 113, 50: 114, 49: 115, 67: $V3, 73: $V4, 75: $V5, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb }), { 20: 28, 22: 116, 23: [2, 58], 49: 118, 50: 117, 64: 29, 65: 38, 66: 39, 67: $V3, 71: 27, 72: 30, 73: $V4, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 20: 28, 33: [2, 98], 49: 121, 50: 120, 63: 119, 64: 29, 65: 38, 66: 39, 67: $V3, 71: 27, 72: 30, 73: $V4, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 33: [1, 122] }, o($Vh, [2, 85]), { 33: [2, 87] }, o($Vi, [2, 48], { 91: 65, 92: $Vj, 93: $Vk }), o($Vl, [2, 35]), o($Vm, [2, 50]), o($Vm, [2, 36]), o($Vp, [2, 107]), o($Vm, [2, 32]), { 20: 28, 49: 125, 50: 124, 64: 29, 65: 38, 66: 39, 67: $V3, 68: [2, 102], 70: 123, 71: 27, 72: 30, 73: $V4, 75: $V5, 82: 31, 83: 32, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb, 90: 41 }, { 56: [1, 126] }, o($Vq, [2, 89]), { 56: [2, 91] }, o($V2, [2, 13]), { 38: 73, 39: $Vr, 43: 74, 44: $Vs, 45: 128, 46: 127, 47: [2, 82] }, o($Vu, [2, 76], { 40: 129 }), { 47: [2, 18] }, o($V2, [2, 14]), { 33: [1, 130] }, o($Vh, [2, 93]), { 33: [2, 95] }, { 33: [1, 131] }, { 32: 132, 33: [2, 68], 78: 133, 79: $Vy }, o($Vu, [2, 65]), o($Vx, [2, 67]), { 33: [2, 74], 37: 135, 78: 136, 79: $Vy }, o($Vu, [2, 71]), o($Vx, [2, 73]), { 23: [1, 137] }, o($Vv, [2, 57]), { 23: [2, 59] }, { 33: [1, 138] }, o($Vh, [2, 97]), { 33: [2, 99] }, o($V2, [2, 23]), { 68: [1, 139] }, o($Vw, [2, 101]), { 68: [2, 103] }, o($V2, [2, 24]), { 47: [2, 19] }, { 47: [2, 83] }, o($Vx, [2, 78], { 71: 27, 20: 28, 64: 29, 72: 30, 82: 31, 83: 32, 65: 38, 66: 39, 90: 41, 41: 140, 50: 141, 49: 142, 67: $V3, 73: $V4, 75: $V5, 84: $V6, 85: $V7, 86: $V8, 87: $V9, 88: $Va, 89: $Vb }), o($V2, [2, 25]), o($V2, [2, 21]), { 33: [1, 143] }, { 33: [2, 69] }, { 73: [1, 145], 80: 144 }, { 33: [1, 146] }, { 33: [2, 75] }, o($Vf, [2, 12]), o($Vg, [2, 27]), o($Vm, [2, 33]), { 33: [2, 80], 42: 147, 78: 148, 79: $Vy }, o($Vu, [2, 77]), o($Vx, [2, 79]), o($Vd, [2, 15]), { 73: [1, 150], 81: [1, 149] }, o($Vz, [2, 108]), o($Ve, [2, 16]), { 33: [1, 151] }, { 33: [2, 81] }, { 33: [2, 37] }, o($Vz, [2, 109]), o($Vd, [2, 17])],\n        defaultActions: { 4: [2, 1], 62: [2, 46], 63: [2, 47], 72: [2, 61], 74: [2, 20], 78: [2, 63], 90: [2, 87], 100: [2, 91], 104: [2, 18], 108: [2, 95], 118: [2, 59], 121: [2, 99], 125: [2, 103], 127: [2, 19], 128: [2, 83], 133: [2, 69], 136: [2, 75], 148: [2, 81], 149: [2, 37] },\n        parseError: function parseError(str, hash) {\n            if (hash.recoverable) {\n                this.trace(str);\n            }\n            else {\n                var error = new Error(str);\n                error.hash = hash;\n                throw error;\n            }\n        },\n        parse: function parse(input) {\n            var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;\n            var args = lstack.slice.call(arguments, 1);\n            var lexer = Object.create(this.lexer);\n            var sharedState = { yy: {} };\n            for (var k in this.yy) {\n                if (Object.prototype.hasOwnProperty.call(this.yy, k)) {\n                    sharedState.yy[k] = this.yy[k];\n                }\n            }\n            lexer.setInput(input, sharedState.yy);\n            sharedState.yy.lexer = lexer;\n            sharedState.yy.parser = this;\n            if (typeof lexer.yylloc == 'undefined') {\n                lexer.yylloc = {};\n            }\n            var yyloc = lexer.yylloc;\n            lstack.push(yyloc);\n            var ranges = lexer.options && lexer.options.ranges;\n            if (typeof sharedState.yy.parseError === 'function') {\n                this.parseError = sharedState.yy.parseError;\n            }\n            else {\n                this.parseError = Object.getPrototypeOf(this).parseError;\n            }\n            function popStack(n) {\n                stack.length = stack.length - 2 * n;\n                vstack.length = vstack.length - n;\n                lstack.length = lstack.length - n;\n            }\n            _token_stack: var lex = function () {\n                var token;\n                token = lexer.lex() || EOF;\n                if (typeof token !== 'number') {\n                    token = self.symbols_[token] || token;\n                }\n                return token;\n            };\n            var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;\n            while (true) {\n                state = stack[stack.length - 1];\n                if (this.defaultActions[state]) {\n                    action = this.defaultActions[state];\n                }\n                else {\n                    if (symbol === null || typeof symbol == 'undefined') {\n                        symbol = lex();\n                    }\n                    action = table[state] && table[state][symbol];\n                }\n                if (typeof action === 'undefined' || !action.length || !action[0]) {\n                    var errStr = '';\n                    expected = [];\n                    for (p in table[state]) {\n                        if (this.terminals_[p] && p > TERROR) {\n                            expected.push('\\'' + this.terminals_[p] + '\\'');\n                        }\n                    }\n                    if (lexer.showPosition) {\n                        errStr = 'Parse error on line ' + (yylineno + 1) + ':\\n' + lexer.showPosition() + '\\nExpecting ' + expected.join(', ') + ', got \\'' + (this.terminals_[symbol] || symbol) + '\\'';\n                    }\n                    else {\n                        errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\\'' + (this.terminals_[symbol] || symbol) + '\\'');\n                    }\n                    this.parseError(errStr, {\n                        text: lexer.match,\n                        token: this.terminals_[symbol] || symbol,\n                        line: lexer.yylineno,\n                        loc: yyloc,\n                        expected: expected\n                    });\n                }\n                if (action[0] instanceof Array && action.length > 1) {\n                    throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);\n                }\n                switch (action[0]) {\n                    case 1:\n                        stack.push(symbol);\n                        vstack.push(lexer.yytext);\n                        lstack.push(lexer.yylloc);\n                        stack.push(action[1]);\n                        symbol = null;\n                        if (!preErrorSymbol) {\n                            yyleng = lexer.yyleng;\n                            yytext = lexer.yytext;\n                            yylineno = lexer.yylineno;\n                            yyloc = lexer.yylloc;\n                            if (recovering > 0) {\n                                recovering--;\n                            }\n                        }\n                        else {\n                            symbol = preErrorSymbol;\n                            preErrorSymbol = null;\n                        }\n                        break;\n                    case 2:\n                        len = this.productions_[action[1]][1];\n                        yyval.$ = vstack[vstack.length - len];\n                        yyval._$ = {\n                            first_line: lstack[lstack.length - (len || 1)].first_line,\n                            last_line: lstack[lstack.length - 1].last_line,\n                            first_column: lstack[lstack.length - (len || 1)].first_column,\n                            last_column: lstack[lstack.length - 1].last_column\n                        };\n                        if (ranges) {\n                            yyval._$.range = [\n                                lstack[lstack.length - (len || 1)].range[0],\n                                lstack[lstack.length - 1].range[1]\n                            ];\n                        }\n                        r = this.performAction.apply(yyval, [\n                            yytext,\n                            yyleng,\n                            yylineno,\n                            sharedState.yy,\n                            action[1],\n                            vstack,\n                            lstack\n                        ].concat(args));\n                        if (typeof r !== 'undefined') {\n                            return r;\n                        }\n                        if (len) {\n                            stack = stack.slice(0, -1 * len * 2);\n                            vstack = vstack.slice(0, -1 * len);\n                            lstack = lstack.slice(0, -1 * len);\n                        }\n                        stack.push(this.productions_[action[1]][0]);\n                        vstack.push(yyval.$);\n                        lstack.push(yyval._$);\n                        newState = table[stack[stack.length - 2]][stack[stack.length - 1]];\n                        stack.push(newState);\n                        break;\n                    case 3:\n                        return true;\n                }\n            }\n            return true;\n        } };\n    /* generated by jison-lex 0.3.4 */\n    var lexer = (function () {\n        var lexer = ({\n            EOF: 1,\n            parseError: function parseError(str, hash) {\n                if (this.yy.parser) {\n                    this.yy.parser.parseError(str, hash);\n                }\n                else {\n                    throw new Error(str);\n                }\n            },\n            // resets the lexer, sets new input\n            setInput: function (input, yy) {\n                this.yy = yy || this.yy || {};\n                this._input = input;\n                this._more = this._backtrack = this.done = false;\n                this.yylineno = this.yyleng = 0;\n                this.yytext = this.matched = this.match = '';\n                this.conditionStack = ['INITIAL'];\n                this.yylloc = {\n                    first_line: 1,\n                    first_column: 0,\n                    last_line: 1,\n                    last_column: 0\n                };\n                if (this.options.ranges) {\n                    this.yylloc.range = [0, 0];\n                }\n                this.offset = 0;\n                return this;\n            },\n            // consumes and returns one char from the input\n            input: function () {\n                var ch = this._input[0];\n                this.yytext += ch;\n                this.yyleng++;\n                this.offset++;\n                this.match += ch;\n                this.matched += ch;\n                var lines = ch.match(/(?:\\r\\n?|\\n).*/g);\n                if (lines) {\n                    this.yylineno++;\n                    this.yylloc.last_line++;\n                }\n                else {\n                    this.yylloc.last_column++;\n                }\n                if (this.options.ranges) {\n                    this.yylloc.range[1]++;\n                }\n                this._input = this._input.slice(1);\n                return ch;\n            },\n            // unshifts one char (or a string) into the input\n            unput: function (ch) {\n                var len = ch.length;\n                var lines = ch.split(/(?:\\r\\n?|\\n)/g);\n                this._input = ch + this._input;\n                this.yytext = this.yytext.substr(0, this.yytext.length - len);\n                //this.yyleng -= len;\n                this.offset -= len;\n                var oldLines = this.match.split(/(?:\\r\\n?|\\n)/g);\n                this.match = this.match.substr(0, this.match.length - 1);\n                this.matched = this.matched.substr(0, this.matched.length - 1);\n                if (lines.length - 1) {\n                    this.yylineno -= lines.length - 1;\n                }\n                var r = this.yylloc.range;\n                this.yylloc = {\n                    first_line: this.yylloc.first_line,\n                    last_line: this.yylineno + 1,\n                    first_column: this.yylloc.first_column,\n                    last_column: lines ?\n                        (lines.length === oldLines.length ? this.yylloc.first_column : 0)\n                            + oldLines[oldLines.length - lines.length].length - lines[0].length :\n                        this.yylloc.first_column - len\n                };\n                if (this.options.ranges) {\n                    this.yylloc.range = [r[0], r[0] + this.yyleng - len];\n                }\n                this.yyleng = this.yytext.length;\n                return this;\n            },\n            // When called from action, caches matched text and appends it on next action\n            more: function () {\n                this._more = true;\n                return this;\n            },\n            // 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.\n            reject: function () {\n                if (this.options.backtrack_lexer) {\n                    this._backtrack = true;\n                }\n                else {\n                    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(), {\n                        text: \"\",\n                        token: null,\n                        line: this.yylineno\n                    });\n                }\n                return this;\n            },\n            // retain first n characters of the match\n            less: function (n) {\n                this.unput(this.match.slice(n));\n            },\n            // displays already matched input, i.e. for error messages\n            pastInput: function () {\n                var past = this.matched.substr(0, this.matched.length - this.match.length);\n                return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\\n/g, \"\");\n            },\n            // displays upcoming input, i.e. for error messages\n            upcomingInput: function () {\n                var next = this.match;\n                if (next.length < 20) {\n                    next += this._input.substr(0, 20 - next.length);\n                }\n                return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\\n/g, \"\");\n            },\n            // displays the character position where the lexing error occurred, i.e. for error messages\n            showPosition: function () {\n                var pre = this.pastInput();\n                var c = new Array(pre.length + 1).join(\"-\");\n                return pre + this.upcomingInput() + \"\\n\" + c + \"^\";\n            },\n            // test the lexed token: return FALSE when not a match, otherwise return token\n            test_match: function (match, indexed_rule) {\n                var token, lines, backup;\n                if (this.options.backtrack_lexer) {\n                    // save context\n                    backup = {\n                        yylineno: this.yylineno,\n                        yylloc: {\n                            first_line: this.yylloc.first_line,\n                            last_line: this.last_line,\n                            first_column: this.yylloc.first_column,\n                            last_column: this.yylloc.last_column\n                        },\n                        yytext: this.yytext,\n                        match: this.match,\n                        matches: this.matches,\n                        matched: this.matched,\n                        yyleng: this.yyleng,\n                        offset: this.offset,\n                        _more: this._more,\n                        _input: this._input,\n                        yy: this.yy,\n                        conditionStack: this.conditionStack.slice(0),\n                        done: this.done\n                    };\n                    if (this.options.ranges) {\n                        backup.yylloc.range = this.yylloc.range.slice(0);\n                    }\n                }\n                lines = match[0].match(/(?:\\r\\n?|\\n).*/g);\n                if (lines) {\n                    this.yylineno += lines.length;\n                }\n                this.yylloc = {\n                    first_line: this.yylloc.last_line,\n                    last_line: this.yylineno + 1,\n                    first_column: this.yylloc.last_column,\n                    last_column: lines ?\n                        lines[lines.length - 1].length - lines[lines.length - 1].match(/\\r?\\n?/)[0].length :\n                        this.yylloc.last_column + match[0].length\n                };\n                this.yytext += match[0];\n                this.match += match[0];\n                this.matches = match;\n                this.yyleng = this.yytext.length;\n                if (this.options.ranges) {\n                    this.yylloc.range = [this.offset, this.offset += this.yyleng];\n                }\n                this._more = false;\n                this._backtrack = false;\n                this._input = this._input.slice(match[0].length);\n                this.matched += match[0];\n                token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);\n                if (this.done && this._input) {\n                    this.done = false;\n                }\n                if (token) {\n                    return token;\n                }\n                else if (this._backtrack) {\n                    // recover context\n                    for (var k in backup) {\n                        this[k] = backup[k];\n                    }\n                    return false; // rule action called reject() implying the next rule should be tested instead.\n                }\n                return false;\n            },\n            // return next match in input\n            next: function () {\n                if (this.done) {\n                    return this.EOF;\n                }\n                if (!this._input) {\n                    this.done = true;\n                }\n                var token, match, tempMatch, index;\n                if (!this._more) {\n                    this.yytext = '';\n                    this.match = '';\n                }\n                var rules = this._currentRules();\n                for (var i = 0; i < rules.length; i++) {\n                    tempMatch = this._input.match(this.rules[rules[i]]);\n                    if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {\n                        match = tempMatch;\n                        index = i;\n                        if (this.options.backtrack_lexer) {\n                            token = this.test_match(tempMatch, rules[i]);\n                            if (token !== false) {\n                                return token;\n                            }\n                            else if (this._backtrack) {\n                                match = false;\n                                continue; // rule action called reject() implying a rule MISmatch.\n                            }\n                            else {\n                                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)\n                                return false;\n                            }\n                        }\n                        else if (!this.options.flex) {\n                            break;\n                        }\n                    }\n                }\n                if (match) {\n                    token = this.test_match(match, rules[index]);\n                    if (token !== false) {\n                        return token;\n                    }\n                    // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)\n                    return false;\n                }\n                if (this._input === \"\") {\n                    return this.EOF;\n                }\n                else {\n                    return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\\n' + this.showPosition(), {\n                        text: \"\",\n                        token: null,\n                        line: this.yylineno\n                    });\n                }\n            },\n            // return next match that has a token\n            lex: function lex() {\n                var r = this.next();\n                if (r) {\n                    return r;\n                }\n                else {\n                    return this.lex();\n                }\n            },\n            // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)\n            begin: function begin(condition) {\n                this.conditionStack.push(condition);\n            },\n            // pop the previously active lexer condition state off the condition stack\n            popState: function popState() {\n                var n = this.conditionStack.length - 1;\n                if (n > 0) {\n                    return this.conditionStack.pop();\n                }\n                else {\n                    return this.conditionStack[0];\n                }\n            },\n            // produce the lexer rule set which is active for the currently active lexer condition state\n            _currentRules: function _currentRules() {\n                if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {\n