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

{"version":3,"file":"index.cjs","sources":["../../../util/lib/object-utils.ts","../../../../../node_modules/.pnpm/@handlebars+parser@2.0.0/node_modules/@handlebars/parser/dist/esm/exception.js","../../../../../node_modules/.pnpm/@handlebars+parser@2.0.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, 44], $V1 = [1, 20], $V2 = [5, 14, 15, 19, 29, 34, 39, 44, 47, 48, 52, 56, 60], $V3 = [1, 35], $V4 = [1, 38], $V5 = [1, 30], $V6 = [1, 31], $V7 = [1, 32], $V8 = [1, 33], $V9 = [1, 34], $Va = [1, 37], $Vb = [14, 15, 19, 29, 34, 39, 44, 47, 48, 52, 56, 60], $Vc = [14, 15, 19, 29, 34, 44, 47, 48, 52, 56, 60], $Vd = [15, 18], $Ve = [14, 15, 19, 29, 34, 47, 48, 52, 56, 60], $Vf = [33, 64, 71, 79, 80, 81, 82, 83, 84], $Vg = [23, 33, 55, 64, 67, 71, 74, 79, 80, 81, 82, 83, 84], $Vh = [1, 51], $Vi = [23, 33, 55, 64, 67, 71, 74, 79, 80, 81, 82, 83, 84, 86], $Vj = [2, 43], $Vk = [55, 64, 71, 79, 80, 81, 82, 83, 84], $Vl = [1, 58], $Vm = [1, 59], $Vn = [1, 66], $Vo = [33, 64, 71, 74, 79, 80, 81, 82, 83, 84], $Vp = [23, 64, 71, 79, 80, 81, 82, 83, 84], $Vq = [1, 76], $Vr = [64, 67, 71, 79, 80, 81, 82, 83, 84], $Vs = [33, 74], $Vt = [23, 33, 55, 67, 71, 74], $Vu = [1, 106], $Vv = [1, 118], $Vw = [71, 76];\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, \"expr\": 49, \"mustache_repetition0\": 50, \"mustache_option0\": 51, \"OPEN_UNESCAPED\": 52, \"mustache_repetition1\": 53, \"mustache_option1\": 54, \"CLOSE_UNESCAPED\": 55, \"OPEN_PARTIAL\": 56, \"partial_repetition0\": 57, \"partial_option0\": 58, \"openPartialBlock\": 59, \"OPEN_PARTIAL_BLOCK\": 60, \"openPartialBlock_repetition0\": 61, \"openPartialBlock_option0\": 62, \"sexpr\": 63, \"OPEN_SEXPR\": 64, \"sexpr_repetition0\": 65, \"sexpr_option0\": 66, \"CLOSE_SEXPR\": 67, \"hash\": 68, \"hash_repetition_plus0\": 69, \"hashSegment\": 70, \"ID\": 71, \"EQUALS\": 72, \"blockParams\": 73, \"OPEN_BLOCK_PARAMS\": 74, \"blockParams_repetition_plus0\": 75, \"CLOSE_BLOCK_PARAMS\": 76, \"path\": 77, \"dataName\": 78, \"STRING\": 79, \"NUMBER\": 80, \"BOOLEAN\": 81, \"UNDEFINED\": 82, \"NULL\": 83, \"DATA\": 84, \"pathSegments\": 85, \"SEP\": 86, \"$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\", 52: \"OPEN_UNESCAPED\", 55: \"CLOSE_UNESCAPED\", 56: \"OPEN_PARTIAL\", 60: \"OPEN_PARTIAL_BLOCK\", 64: \"OPEN_SEXPR\", 67: \"CLOSE_SEXPR\", 71: \"ID\", 72: \"EQUALS\", 74: \"OPEN_BLOCK_PARAMS\", 76: \"CLOSE_BLOCK_PARAMS\", 79: \"STRING\", 80: \"NUMBER\", 81: \"BOOLEAN\", 82: \"UNDEFINED\", 83: \"NULL\", 84: \"DATA\", 86: \"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, 5], [8, 5], [11, 5], [12, 3], [59, 5], [49, 1], [49, 1], [63, 5], [68, 1], [70, 3], [73, 3], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [78, 2], [77, 1], [85, 3], [85, 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], [50, 0], [50, 2], [51, 0], [51, 1], [53, 0], [53, 2], [54, 0], [54, 1], [57, 0], [57, 2], [58, 0], [58, 1], [61, 0], [61, 2], [62, 0], [62, 1], [65, 0], [65, 2], [66, 0], [66, 1], [69, 1], [69, 2], [75, 1], [75, 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 27:\n                case 28:\n                case 33:\n                case 34:\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                case 23:\n                    this.$ = yy.prepareMustache($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0 - 4], yy.stripFlags($$[$0 - 4], $$[$0]), this._$);\n                    break;\n                case 24:\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 25:\n                    this.$ = yy.preparePartialBlock($$[$0 - 2], $$[$0 - 1], $$[$0], this._$);\n                    break;\n                case 26:\n                    this.$ = { path: $$[$0 - 3], params: $$[$0 - 2], hash: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 4], $$[$0]) };\n                    break;\n                case 29:\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 30:\n                    this.$ = { type: 'Hash', pairs: $$[$0], loc: yy.locInfo(this._$) };\n                    break;\n                case 31:\n                    this.$ = { type: 'HashPair', key: yy.id($$[$0 - 2]), value: $$[$0], loc: yy.locInfo(this._$) };\n                    break;\n                case 32:\n                    this.$ = yy.id($$[$0 - 1]);\n                    break;\n                case 35:\n                    this.$ = { type: 'StringLiteral', value: $$[$0], original: $$[$0], loc: yy.locInfo(this._$) };\n                    break;\n                case 36:\n                    this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };\n                    break;\n                case 37:\n                    this.$ = { type: 'BooleanLiteral', value: $$[$0] === 'true', original: $$[$0] === 'true', loc: yy.locInfo(this._$) };\n                    break;\n                case 38:\n                    this.$ = { type: 'UndefinedLiteral', original: undefined, value: undefined, loc: yy.locInfo(this._$) };\n                    break;\n                case 39:\n                    this.$ = { type: 'NullLiteral', original: null, value: null, loc: yy.locInfo(this._$) };\n                    break;\n                case 40:\n                    this.$ = yy.preparePath(true, $$[$0], this._$);\n                    break;\n                case 41:\n                    this.$ = yy.preparePath(false, $$[$0], this._$);\n                    break;\n                case 42:\n                    $$[$0 - 2].push({ part: yy.id($$[$0]), original: $$[$0], separator: $$[$0 - 1] });\n                    this.$ = $$[$0 - 2];\n                    break;\n                case 43:\n                    this.$ = [{ part: yy.id($$[$0]), original: $$[$0] }];\n                    break;\n                case 44:\n                case 46:\n                case 48:\n                case 56:\n                case 62:\n                case 68:\n                case 76:\n                case 80:\n                case 84:\n                case 88:\n                case 92:\n                    this.$ = [];\n                    break;\n                case 45:\n                case 47:\n                case 49:\n                case 57:\n                case 63:\n                case 69:\n                case 77:\n                case 81:\n                case 85:\n                case 89:\n                case 93:\n                case 97:\n                case 99:\n                    $$[$0 - 1].push($$[$0]);\n                    break;\n                case 96:\n                case 98:\n                    this.$ = [$$[$0]];\n                    break;\n            }\n        },\n        table: [o([5, 14, 15, 19, 29, 34, 48, 52, 56, 60], $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, 59: 19, 14: [1, 12], 15: $V1, 19: [1, 23], 29: [1, 21], 34: [1, 22], 48: [1, 13], 52: [1, 14], 56: [1, 18], 60: [1, 24] }), { 1: [2, 1] }, o($V2, [2, 45]), 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: 26, 49: 25, 63: 27, 64: $V3, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, { 20: 26, 49: 39, 63: 27, 64: $V3, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, o($Vb, $V0, { 6: 3, 4: 40 }), o($Vc, $V0, { 6: 3, 4: 41 }), o($Vd, [2, 46], { 17: 42 }), { 20: 26, 49: 43, 63: 27, 64: $V3, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, o($Ve, $V0, { 6: 3, 4: 44 }), o([5, 14, 15, 18, 19, 29, 34, 39, 44, 47, 48, 52, 56, 60], [2, 10]), { 20: 45, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, { 20: 46, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, { 20: 47, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, { 20: 26, 49: 48, 63: 27, 64: $V3, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, o($Vf, [2, 76], { 50: 49 }), o($Vg, [2, 27]), o($Vg, [2, 28]), o($Vg, [2, 33]), o($Vg, [2, 34]), o($Vg, [2, 35]), o($Vg, [2, 36]), o($Vg, [2, 37]), o($Vg, [2, 38]), o($Vg, [2, 39]), { 20: 26, 49: 50, 63: 27, 64: $V3, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, o($Vg, [2, 41], { 86: $Vh }), { 71: $V4, 85: 52 }, o($Vi, $Vj), o($Vk, [2, 80], { 53: 53 }), { 25: 54, 38: 56, 39: $Vl, 43: 57, 44: $Vm, 45: 55, 47: [2, 52] }, { 28: 60, 43: 61, 44: $Vm, 47: [2, 54] }, { 13: 63, 15: $V1, 18: [1, 62] }, o($Vf, [2, 84], { 57: 64 }), { 26: 65, 47: $Vn }, o($Vo, [2, 56], { 30: 67 }), o($Vo, [2, 62], { 35: 68 }), o($Vp, [2, 48], { 21: 69 }), o($Vf, [2, 88], { 61: 70 }), { 20: 26, 33: [2, 78], 49: 72, 51: 71, 63: 27, 64: $V3, 68: 73, 69: 74, 70: 75, 71: $Vq, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, o($Vr, [2, 92], { 65: 77 }), { 71: [1, 78] }, o($Vg, [2, 40], { 86: $Vh }), { 20: 26, 49: 80, 54: 79, 55: [2, 82], 63: 27, 64: $V3, 68: 81, 69: 74, 70: 75, 71: $Vq, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, { 26: 82, 47: $Vn }, { 47: [2, 53] }, o($Vb, $V0, { 6: 3, 4: 83 }), { 47: [2, 20] }, { 20: 84, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, o($Ve, $V0, { 6: 3, 4: 85 }), { 26: 86, 47: $Vn }, { 47: [2, 55] }, o($V2, [2, 11]), o($Vd, [2, 47]), { 20: 26, 33: [2, 86], 49: 88, 58: 87, 63: 27, 64: $V3, 68: 89, 69: 74, 70: 75, 71: $Vq, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, o($V2, [2, 25]), { 20: 90, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, o($Vs, [2, 58], { 20: 26, 63: 27, 77: 28, 78: 29, 85: 36, 69: 74, 70: 75, 31: 91, 49: 92, 68: 93, 64: $V3, 71: $Vq, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va }), o($Vs, [2, 64], { 20: 26, 63: 27, 77: 28, 78: 29, 85: 36, 69: 74, 70: 75, 36: 94, 49: 95, 68: 96, 64: $V3, 71: $Vq, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va }), { 20: 26, 22: 97, 23: [2, 50], 49: 98, 63: 27, 64: $V3, 68: 99, 69: 74, 70: 75, 71: $Vq, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, { 20: 26, 33: [2, 90], 49: 101, 62: 100, 63: 27, 64: $V3, 68: 102, 69: 74, 70: 75, 71: $Vq, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, { 33: [1, 103] }, o($Vf, [2, 77]), { 33: [2, 79] }, o([23, 33, 55, 67, 74], [2, 30], { 70: 104, 71: [1, 105] }), o($Vt, [2, 96]), o($Vi, $Vj, { 72: $Vu }), { 20: 26, 49: 108, 63: 27, 64: $V3, 66: 107, 67: [2, 94], 68: 109, 69: 74, 70: 75, 71: $Vq, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, o($Vi, [2, 42]), { 55: [1, 110] }, o($Vk, [2, 81]), { 55: [2, 83] }, o($V2, [2, 13]), { 38: 56, 39: $Vl, 43: 57, 44: $Vm, 45: 112, 46: 111, 47: [2, 74] }, o($Vo, [2, 68], { 40: 113 }), { 47: [2, 18] }, o($V2, [2, 14]), { 33: [1, 114] }, o($Vf, [2, 85]), { 33: [2, 87] }, { 33: [1, 115] }, { 32: 116, 33: [2, 60], 73: 117, 74: $Vv }, o($Vo, [2, 57]), o($Vs, [2, 59]), { 33: [2, 66], 37: 119, 73: 120, 74: $Vv }, o($Vo, [2, 63]), o($Vs, [2, 65]), { 23: [1, 121] }, o($Vp, [2, 49]), { 23: [2, 51] }, { 33: [1, 122] }, o($Vf, [2, 89]), { 33: [2, 91] }, o($V2, [2, 22]), o($Vt, [2, 97]), { 72: $Vu }, { 20: 26, 49: 123, 63: 27, 64: $V3, 71: $V4, 77: 28, 78: 29, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va, 85: 36 }, { 67: [1, 124] }, o($Vr, [2, 93]), { 67: [2, 95] }, o($V2, [2, 23]), { 47: [2, 19] }, { 47: [2, 75] }, o($Vs, [2, 70], { 20: 26, 63: 27, 77: 28, 78: 29, 85: 36, 69: 74, 70: 75, 41: 125, 49: 126, 68: 127, 64: $V3, 71: $Vq, 79: $V5, 80: $V6, 81: $V7, 82: $V8, 83: $V9, 84: $Va }), o($V2, [2, 24]), o($V2, [2, 21]), { 33: [1, 128] }, { 33: [2, 61] }, { 71: [1, 130], 75: 129 }, { 33: [1, 131] }, { 33: [2, 67] }, o($Vd, [2, 12]), o($Ve, [2, 26]), o($Vt, [2, 31]), o($Vg, [2, 29]), { 33: [2, 72], 42: 132, 73: 133, 74: $Vv }, o($Vo, [2, 69]), o($Vs, [2, 71]), o($Vb, [2, 15]), { 71: [1, 135], 76: [1, 134] }, o($Vw, [2, 98]), o($Vc, [2, 16]), { 33: [1, 136] }, { 33: [2, 73] }, { 33: [2, 32] }, o($Vw, [2, 99]), o($Vb, [2, 17])],\n        defaultActions: { 4: [2, 1], 55: [2, 53], 57: [2, 20], 61: [2, 55], 73: [2, 79], 81: [2, 83], 85: [2, 18], 89: [2, 87], 99: [2, 51], 102: [2, 91], 109: [2, 95], 111: [2, 19], 112: [2, 75], 117: [2, 61], 120: [2, 67], 133: [2, 73], 134: [2, 32] },\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                    return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;\n                }\n                else {\n                    return this.conditions[\"INITIAL\"].rules;\n                }\n            },\n            // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available\n            topState: function topState(n) {\n                n = this.conditionStack.length - 1 - Math.abs(n || 0);\n                if (n >= 0) {\n                    return this.conditionStack[n];\n                }\n                else {\n                    return \"INITIAL\";\n                }\n            },\n            // alias for begin(condition)\n            pushState: function pushState(condition) {\n                this.begin(condition);\n            },\n            // return the number of states currently on the stack\n            stateStackSize: function stateStackSize() {\n                return this.conditionStack.length;\n            },\n            options: {},\n            performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {\n                function strip(start, end) {\n                    return yy_.yytext = yy_.yytext.substring(start, yy_.yyleng - end + start);\n                }\n                var YYSTATE = YY_START;\n                switch ($avoiding_name_collisions) {\n                    case 0:\n                        if (yy_.yytext.slice(-2) === \"\\\\\\\\\") {\n                            strip(0, 1);\n                            this.begin(\"mu\");\n                        }\n                        else if (yy_.yytext.slice(-1) === \"\\\\\") {\n                            strip(0, 1);\n                            this.begin(\"emu\");\n                        }\n                        else {\n                            this.begin(\"mu\");\n                        }\n                        if (yy_.yytext)\n                            return 15;\n                        break;\n                    case 1:\n                        return 15;\n                        break;\n                    case 2:\n                        this.popState();\n                        return 15;\n                        break;\n                    case 3:\n                        this.begin('raw');\n                        return 15;\n                        break;\n                    case 4:\n                        this.popState();\n                        // Should be using `this.topState()` below, but it currently\n                        // returns the second top instead of the first top. Opened an\