| // File ignored in coverage tests via setting in .istanbul.yml |
| /* parser generated by jison 0.4.16 */ |
| /* |
| 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 handlebars = (function(){ |
| var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[2,46],$V1=[1,20],$V2=[5,14,15,19,29,34,39,44,47,48,51,55,60],$V3=[1,35],$V4=[1,28],$V5=[1,29],$V6=[1,30],$V7=[1,31],$V8=[1,32],$V9=[1,34],$Va=[14,15,19,29,34,39,44,47,48,51,55,60],$Vb=[14,15,19,29,34,44,47,48,51,55,60],$Vc=[1,44],$Vd=[14,15,19,29,34,47,48,51,55,60],$Ve=[33,65,72,80,81,82,83,84,85],$Vf=[23,33,54,65,68,72,75,80,81,82,83,84,85],$Vg=[1,51],$Vh=[23,33,54,65,68,72,75,80,81,82,83,84,85,87],$Vi=[2,45],$Vj=[54,65,72,80,81,82,83,84,85],$Vk=[1,58],$Vl=[1,59],$Vm=[15,18],$Vn=[1,67],$Vo=[33,65,72,75,80,81,82,83,84,85],$Vp=[23,65,72,80,81,82,83,84,85],$Vq=[1,79],$Vr=[65,68,72,80,81,82,83,84,85],$Vs=[33,75],$Vt=[23,33,54,68,72,75],$Vu=[1,109],$Vv=[1,121],$Vw=[72,77]; |
| var parser = {trace: function trace () { }, |
| yy: {}, |
| 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_repetition_plus0":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,"mustache_repetition0":49,"mustache_option0":50,"OPEN_UNESCAPED":51,"mustache_repetition1":52,"mustache_option1":53,"CLOSE_UNESCAPED":54,"OPEN_PARTIAL":55,"partialName":56,"partial_repetition0":57,"partial_option0":58,"openPartialBlock":59,"OPEN_PARTIAL_BLOCK":60,"openPartialBlock_repetition0":61,"openPartialBlock_option0":62,"param":63,"sexpr":64,"OPEN_SEXPR":65,"sexpr_repetition0":66,"sexpr_option0":67,"CLOSE_SEXPR":68,"hash":69,"hash_repetition_plus0":70,"hashSegment":71,"ID":72,"EQUALS":73,"blockParams":74,"OPEN_BLOCK_PARAMS":75,"blockParams_repetition_plus0":76,"CLOSE_BLOCK_PARAMS":77,"path":78,"dataName":79,"STRING":80,"NUMBER":81,"BOOLEAN":82,"UNDEFINED":83,"NULL":84,"DATA":85,"pathSegments":86,"SEP":87,"$accept":0,"$end":1}, |
| 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",51:"OPEN_UNESCAPED",54:"CLOSE_UNESCAPED",55:"OPEN_PARTIAL",60:"OPEN_PARTIAL_BLOCK",65:"OPEN_SEXPR",68:"CLOSE_SEXPR",72:"ID",73:"EQUALS",75:"OPEN_BLOCK_PARAMS",77:"CLOSE_BLOCK_PARAMS",80:"STRING",81:"NUMBER",82:"BOOLEAN",83:"UNDEFINED",84:"NULL",85:"DATA",87:"SEP"}, |
| 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],[63,1],[63,1],[64,5],[69,1],[71,3],[74,3],[20,1],[20,1],[20,1],[20,1],[20,1],[20,1],[20,1],[56,1],[56,1],[79,2],[78,1],[86,3],[86,1],[6,0],[6,2],[17,1],[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],[49,0],[49,2],[50,0],[50,1],[52,0],[52,2],[53,0],[53,1],[57,0],[57,2],[58,0],[58,1],[61,0],[61,2],[62,0],[62,1],[66,0],[66,2],[67,0],[67,1],[70,1],[70,2],[76,1],[76,2]], |
| performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) { |
| /* this == yyval */ |
| |
| var $0 = $$.length - 1; |
| switch (yystate) { |
| case 1: |
| return $$[$0-1]; |
| break; |
| case 2: |
| this.$ = yy.prepareProgram($$[$0]); |
| break; |
| case 3: case 4: case 5: case 6: case 7: case 8: case 20: case 27: case 28: case 33: case 34: case 40: case 41: |
| this.$ = $$[$0]; |
| break; |
| case 9: |
| |
| this.$ = { |
| type: 'CommentStatement', |
| value: yy.stripComment($$[$0]), |
| strip: yy.stripFlags($$[$0], $$[$0]), |
| loc: yy.locInfo(this._$) |
| }; |
| |
| break; |
| case 10: |
| |
| this.$ = { |
| type: 'ContentStatement', |
| original: $$[$0], |
| value: $$[$0], |
| loc: yy.locInfo(this._$) |
| }; |
| |
| break; |
| case 11: |
| this.$ = yy.prepareRawBlock($$[$0-2], $$[$0-1], $$[$0], this._$); |
| break; |
| case 12: |
| this.$ = { path: $$[$0-3], params: $$[$0-2], hash: $$[$0-1] }; |
| break; |
| case 13: |
| this.$ = yy.prepareBlock($$[$0-3], $$[$0-2], $$[$0-1], $$[$0], false, this._$); |
| break; |
| case 14: |
| this.$ = yy.prepareBlock($$[$0-3], $$[$0-2], $$[$0-1], $$[$0], true, this._$); |
| break; |
| case 15: |
| this.$ = { open: $$[$0-5], path: $$[$0-4], params: $$[$0-3], hash: $$[$0-2], blockParams: $$[$0-1], strip: yy.stripFlags($$[$0-5], $$[$0]) }; |
| break; |
| case 16: case 17: |
| this.$ = { path: $$[$0-4], params: $$[$0-3], hash: $$[$0-2], blockParams: $$[$0-1], strip: yy.stripFlags($$[$0-5], $$[$0]) }; |
| break; |
| case 18: |
| this.$ = { strip: yy.stripFlags($$[$0-1], $$[$0-1]), program: $$[$0] }; |
| break; |
| case 19: |
| |
| var inverse = yy.prepareBlock($$[$0-2], $$[$0-1], $$[$0], $$[$0], false, this._$), |
| program = yy.prepareProgram([inverse], $$[$0-1].loc); |
| program.chained = true; |
| |
| this.$ = { strip: $$[$0-2].strip, program: program, chain: true }; |
| |
| break; |
| case 21: |
| this.$ = {path: $$[$0-1], strip: yy.stripFlags($$[$0-2], $$[$0])}; |
| break; |
| case 22: case 23: |
| this.$ = yy.prepareMustache($$[$0-3], $$[$0-2], $$[$0-1], $$[$0-4], yy.stripFlags($$[$0-4], $$[$0]), this._$); |
| break; |
| case 24: |
| |
| this.$ = { |
| type: 'PartialStatement', |
| name: $$[$0-3], |
| params: $$[$0-2], |
| hash: $$[$0-1], |
| indent: '', |
| strip: yy.stripFlags($$[$0-4], $$[$0]), |
| loc: yy.locInfo(this._$) |
| }; |
| |
| break; |
| case 25: |
| this.$ = yy.preparePartialBlock($$[$0-2], $$[$0-1], $$[$0], this._$); |
| break; |
| case 26: |
| this.$ = { path: $$[$0-3], params: $$[$0-2], hash: $$[$0-1], strip: yy.stripFlags($$[$0-4], $$[$0]) }; |
| break; |
| case 29: |
| |
| this.$ = { |
| type: 'SubExpression', |
| path: $$[$0-3], |
| params: $$[$0-2], |
| hash: $$[$0-1], |
| loc: yy.locInfo(this._$) |
| }; |
| |
| break; |
| case 30: |
| this.$ = {type: 'Hash', pairs: $$[$0], loc: yy.locInfo(this._$)}; |
| break; |
| case 31: |
| this.$ = {type: 'HashPair', key: yy.id($$[$0-2]), value: $$[$0], loc: yy.locInfo(this._$)}; |
| break; |
| case 32: |
| this.$ = yy.id($$[$0-1]); |
| break; |
| case 35: |
| this.$ = {type: 'StringLiteral', value: $$[$0], original: $$[$0], loc: yy.locInfo(this._$)}; |
| break; |
| case 36: |
| this.$ = {type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$)}; |
| break; |
| case 37: |
| this.$ = {type: 'BooleanLiteral', value: $$[$0] === 'true', original: $$[$0] === 'true', loc: yy.locInfo(this._$)}; |
| break; |
| case 38: |
| this.$ = {type: 'UndefinedLiteral', original: undefined, value: undefined, loc: yy.locInfo(this._$)}; |
| break; |
| case 39: |
| this.$ = {type: 'NullLiteral', original: null, value: null, loc: yy.locInfo(this._$)}; |
| break; |
| case 42: |
| this.$ = yy.preparePath(true, $$[$0], this._$); |
| break; |
| case 43: |
| this.$ = yy.preparePath(false, $$[$0], this._$); |
| break; |
| case 44: |
| $$[$0-2].push({part: yy.id($$[$0]), original: $$[$0], separator: $$[$0-1]}); this.$ = $$[$0-2]; |
| break; |
| case 45: |
| this.$ = [{part: yy.id($$[$0]), original: $$[$0]}]; |
| break; |
| case 46: case 50: case 58: case 64: case 70: case 78: case 82: case 86: case 90: case 94: |
| this.$ = []; |
| break; |
| case 47: case 49: case 51: case 59: case 65: case 71: case 79: case 83: case 87: case 91: case 95: case 99: case 101: |
| $$[$0-1].push($$[$0]); |
| break; |
| case 48: case 98: case 100: |
| this.$ = [$$[$0]]; |
| break; |
| } |
| }, |
| table: [o([5,14,15,19,29,34,48,51,55,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],51:[1,14],55:[1,18],60:[1,24]}),{1:[2,1]},o($V2,[2,47]),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:25,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{20:36,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},o($Va,$V0,{6:3,4:37}),o($Vb,$V0,{6:3,4:38}),{13:40,15:$V1,17:39},{20:42,56:41,64:43,65:$Vc,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},o($Vd,$V0,{6:3,4:45}),o([5,14,15,18,19,29,34,39,44,47,48,51,55,60],[2,10]),{20:46,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{20:47,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{20:48,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{20:42,56:49,64:43,65:$Vc,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},o($Ve,[2,78],{49:50}),o($Vf,[2,33]),o($Vf,[2,34]),o($Vf,[2,35]),o($Vf,[2,36]),o($Vf,[2,37]),o($Vf,[2,38]),o($Vf,[2,39]),o($Vf,[2,43],{87:$Vg}),{72:$V3,86:52},o($Vh,$Vi),o($Vj,[2,82],{52:53}),{25:54,38:56,39:$Vk,43:57,44:$Vl,45:55,47:[2,54]},{28:60,43:61,44:$Vl,47:[2,56]},{13:63,15:$V1,18:[1,62]},o($Vm,[2,48]),o($Ve,[2,86],{57:64}),o($Ve,[2,40]),o($Ve,[2,41]),{20:65,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{26:66,47:$Vn},o($Vo,[2,58],{30:68}),o($Vo,[2,64],{35:69}),o($Vp,[2,50],{21:70}),o($Ve,[2,90],{61:71}),{20:75,33:[2,80],50:72,63:73,64:76,65:$Vc,69:74,70:77,71:78,72:$Vq,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{72:[1,80]},o($Vf,[2,42],{87:$Vg}),{20:75,53:81,54:[2,84],63:82,64:76,65:$Vc,69:83,70:77,71:78,72:$Vq,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{26:84,47:$Vn},{47:[2,55]},o($Va,$V0,{6:3,4:85}),{47:[2,20]},{20:86,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},o($Vd,$V0,{6:3,4:87}),{26:88,47:$Vn},{47:[2,57]},o($V2,[2,11]),o($Vm,[2,49]),{20:75,33:[2,88],58:89,63:90,64:76,65:$Vc,69:91,70:77,71:78,72:$Vq,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},o($Vr,[2,94],{66:92}),o($V2,[2,25]),{20:93,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},o($Vs,[2,60],{78:26,79:27,86:33,20:75,64:76,70:77,71:78,31:94,63:95,69:96,65:$Vc,72:$Vq,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9}),o($Vs,[2,66],{78:26,79:27,86:33,20:75,64:76,70:77,71:78,36:97,63:98,69:99,65:$Vc,72:$Vq,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9}),{20:75,22:100,23:[2,52],63:101,64:76,65:$Vc,69:102,70:77,71:78,72:$Vq,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{20:75,33:[2,92],62:103,63:104,64:76,65:$Vc,69:105,70:77,71:78,72:$Vq,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{33:[1,106]},o($Ve,[2,79]),{33:[2,81]},o($Vf,[2,27]),o($Vf,[2,28]),o([23,33,54,68,75],[2,30],{71:107,72:[1,108]}),o($Vt,[2,98]),o($Vh,$Vi,{73:$Vu}),o($Vh,[2,44]),{54:[1,110]},o($Vj,[2,83]),{54:[2,85]},o($V2,[2,13]),{38:56,39:$Vk,43:57,44:$Vl,45:112,46:111,47:[2,76]},o($Vo,[2,70],{40:113}),{47:[2,18]},o($V2,[2,14]),{33:[1,114]},o($Ve,[2,87]),{33:[2,89]},{20:75,63:116,64:76,65:$Vc,67:115,68:[2,96],69:117,70:77,71:78,72:$Vq,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},{33:[1,118]},{32:119,33:[2,62],74:120,75:$Vv},o($Vo,[2,59]),o($Vs,[2,61]),{33:[2,68],37:122,74:123,75:$Vv},o($Vo,[2,65]),o($Vs,[2,67]),{23:[1,124]},o($Vp,[2,51]),{23:[2,53]},{33:[1,125]},o($Ve,[2,91]),{33:[2,93]},o($V2,[2,22]),o($Vt,[2,99]),{73:$Vu},{20:75,63:126,64:76,65:$Vc,72:$V3,78:26,79:27,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9,86:33},o($V2,[2,23]),{47:[2,19]},{47:[2,77]},o($Vs,[2,72],{78:26,79:27,86:33,20:75,64:76,70:77,71:78,41:127,63:128,69:129,65:$Vc,72:$Vq,80:$V4,81:$V5,82:$V6,83:$V7,84:$V8,85:$V9}),o($V2,[2,24]),{68:[1,130]},o($Vr,[2,95]),{68:[2,97]},o($V2,[2,21]),{33:[1,131]},{33:[2,63]},{72:[1,133],76:132},{33:[1,134]},{33:[2,69]},{15:[2,12]},o($Vd,[2,26]),o($Vt,[2,31]),{33:[2,74],42:135,74:136,75:$Vv},o($Vo,[2,71]),o($Vs,[2,73]),o($Vf,[2,29]),o($Va,[2,15]),{72:[1,138],77:[1,137]},o($Vw,[2,100]),o($Vb,[2,16]),{33:[1,139]},{33:[2,75]},{33:[2,32]},o($Vw,[2,101]),o($Va,[2,17])], |
| defaultActions: {4:[2,1],55:[2,55],57:[2,20],61:[2,57],74:[2,81],83:[2,85],87:[2,18],91:[2,89],102:[2,53],105:[2,93],111:[2,19],112:[2,77],117:[2,97],120:[2,63],123:[2,69],124:[2,12],136:[2,75],137:[2,32]}, |
| parseError: function parseError (str, hash) { |
| if (hash.recoverable) { |
| this.trace(str); |
| } else { |
| function _parseError (msg, hash) { |
| this.message = msg; |
| this.hash = hash; |
| } |
| _parseError.prototype = new Error(); |
| |
| throw new _parseError(str, hash); |
| } |
| }, |
| 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: {}, |
| performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) { |
| |
| function strip(start, end) { |
| return yy_.yytext = yy_.yytext.substring(start, yy_.yyleng - end + start); |
| } |
| |
| |
| var YYSTATE=YY_START; |
| switch($avoiding_name_collisions) { |
| case 0: |
| if(yy_.yytext.slice(-2) === "\\\\") { |
| strip(0,1); |
| this.begin("mu"); |
| } else if(yy_.yytext.slice(-1) === "\\") { |
| strip(0,1); |
| this.begin("emu"); |
| } else { |
| this.begin("mu"); |
| } |
| if(yy_.yytext) return 15; |
| |
| break; |
| case 1:return 15; |
| break; |
| case 2: |
| this.popState(); |
| return 15; |
| |
| break; |
| case 3:this.begin('raw'); return 15; |
| break; |
| case 4: |
| this.popState(); |
| // Should be using `this.topState()` below, but it currently |
| // returns the second top instead of the first top. Opened an |
| // issue about it at https://github.com/zaach/jison/issues/291 |
| if (this.conditionStack[this.conditionStack.length-1] === 'raw') { |
| return 15; |
| } else { |
| strip(5, 9); |
| return 18; |
| } |
| |
| break; |
| case 5: return 15; |
| break; |
| case 6: |
| this.popState(); |
| return 14; |
| |
| break; |
| case 7:return 65; |
| break; |
| case 8:return 68; |
| break; |
| case 9: return 19; |
| break; |
| case 10: |
| this.popState(); |
| this.begin('raw'); |
| return 23; |
| |
| break; |
| case 11:return 55; |
| break; |
| case 12:return 60; |
| break; |
| case 13:return 29; |
| break; |
| case 14:return 47; |
| break; |
| case 15:this.popState(); return 44; |
| break; |
| case 16:this.popState(); return 44; |
| break; |
| case 17:return 34; |
| break; |
| case 18:return 39; |
| break; |
| case 19:return 51; |
| break; |
| case 20:return 48; |
| break; |
| case 21: |
| this.unput(yy_.yytext); |
| this.popState(); |
| this.begin('com'); |
| |
| break; |
| case 22: |
| this.popState(); |
| return 14; |
| |
| break; |
| case 23:return 48; |
| break; |
| case 24:return 73; |
| break; |
| case 25:return 72; |
| break; |
| case 26:return 72; |
| break; |
| case 27:return 87; |
| break; |
| case 28:// ignore whitespace |
| break; |
| case 29:this.popState(); return 54; |
| break; |
| case 30:this.popState(); return 33; |
| break; |
| case 31:yy_.yytext = strip(1,2).replace(/\\"/g,'"'); return 80; |
| break; |
| case 32:yy_.yytext = strip(1,2).replace(/\\'/g,"'"); return 80; |
| break; |
| case 33:return 85; |
| break; |
| case 34:return 82; |
| break; |
| case 35:return 82; |
| break; |
| case 36:return 83; |
| break; |
| case 37:return 84; |
| break; |
| case 38:return 81; |
| break; |
| case 39:return 75; |
| break; |
| case 40:return 77; |
| break; |
| case 41:return 72; |
| break; |
| case 42:yy_.yytext = yy_.yytext.replace(/\\([\\\]])/g,'$1'); return 72; |
| break; |
| case 43:return 'INVALID'; |
| break; |
| case 44:return 5; |
| break; |
| } |
| }, |
| rules: [/^(?:[^\x00]*?(?=(\{\{)))/,/^(?:[^\x00]+)/,/^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/,/^(?:\{\{\{\{(?=[^\/]))/,/^(?:\{\{\{\{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.])\}\}\}\})/,/^(?:[^\x00]*?(?=(\{\{\{\{)))/,/^(?:[\s\S]*?--(~)?\}\})/,/^(?:\()/,/^(?:\))/,/^(?:\{\{\{\{)/,/^(?:\}\}\}\})/,/^(?:\{\{(~)?>)/,/^(?:\{\{(~)?#>)/,/^(?:\{\{(~)?#\*?)/,/^(?:\{\{(~)?\/)/,/^(?:\{\{(~)?\^\s*(~)?\}\})/,/^(?:\{\{(~)?\s*else\s*(~)?\}\})/,/^(?:\{\{(~)?\^)/,/^(?:\{\{(~)?\s*else\b)/,/^(?:\{\{(~)?\{)/,/^(?:\{\{(~)?&)/,/^(?:\{\{(~)?!--)/,/^(?:\{\{(~)?![\s\S]*?\}\})/,/^(?:\{\{(~)?\*?)/,/^(?:=)/,/^(?:\.\.)/,/^(?:\.(?=([=~}\s\/.)|])))/,/^(?:[\/.])/,/^(?:\s+)/,/^(?:\}(~)?\}\})/,/^(?:(~)?\}\})/,/^(?:"(\\["]|[^"])*")/,/^(?:'(\\[']|[^'])*')/,/^(?:@)/,/^(?:true(?=([~}\s)])))/,/^(?:false(?=([~}\s)])))/,/^(?:undefined(?=([~}\s)])))/,/^(?:null(?=([~}\s)])))/,/^(?:-?[0-9]+(?:\.[0-9]+)?(?=([~}\s)])))/,/^(?:as\s+\|)/,/^(?:\|)/,/^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)|]))))/,/^(?:\[(\\\]|[^\]])*\])/,/^(?:.)/,/^(?:$)/], |
| conditions: {"mu":{"rules":[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],"inclusive":false},"emu":{"rules":[2],"inclusive":false},"com":{"rules":[6],"inclusive":false},"raw":{"rules":[3,4,5],"inclusive":false},"INITIAL":{"rules":[0,1,44],"inclusive":true}} |
| }); |
| return lexer; |
| })(); |
| parser.lexer = lexer; |
| function Parser () { |
| this.yy = {}; |
| } |
| Parser.prototype = parser;parser.Parser = Parser; |
| return new Parser; |
| })();export default handlebars; |
