blocks
4 months ago
cleditor
4 years ago
codemirror
2 years ago
dfv
3 months ago
marionette
7 years ago
qtip
5 years ago
selectWoo
5 years ago
sprintf
8 years ago
timepicker
8 years ago
handlebars.js
8 years ago
jquery.pods.js
1 year ago
jquery.pods.upgrade.js
5 years ago
pods-i18n.js
8 years ago
pods-link-picker.js
11 months ago
qtip.js
3 years ago
react-jsx-runtime.js
3 months ago
react-jsx-runtime.js.LICENSE.txt
1 year ago
handlebars.js
1551 lines
| 1 | // lib/handlebars/base.js |
| 2 | var Handlebars = {}; |
| 3 | |
| 4 | Handlebars.VERSION = "1.0.beta.6"; |
| 5 | |
| 6 | Handlebars.helpers = {}; |
| 7 | Handlebars.partials = {}; |
| 8 | |
| 9 | Handlebars.registerHelper = function(name, fn, inverse) { |
| 10 | if(inverse) { fn.not = inverse; } |
| 11 | this.helpers[name] = fn; |
| 12 | }; |
| 13 | |
| 14 | Handlebars.registerPartial = function(name, str) { |
| 15 | this.partials[name] = str; |
| 16 | }; |
| 17 | |
| 18 | Handlebars.registerHelper('helperMissing', function(arg) { |
| 19 | if(arguments.length === 2) { |
| 20 | return undefined; |
| 21 | } else { |
| 22 | throw new Error("Could not find property '" + arg + "'"); |
| 23 | } |
| 24 | }); |
| 25 | |
| 26 | var toString = Object.prototype.toString, functionType = "[object Function]"; |
| 27 | |
| 28 | Handlebars.registerHelper('blockHelperMissing', function(context, options) { |
| 29 | var inverse = options.inverse || function() {}, fn = options.fn; |
| 30 | |
| 31 | |
| 32 | var ret = ""; |
| 33 | var type = toString.call(context); |
| 34 | |
| 35 | if(type === functionType) { context = context.call(this); } |
| 36 | |
| 37 | if(context === true) { |
| 38 | return fn(this); |
| 39 | } else if(context === false || context == null) { |
| 40 | return inverse(this); |
| 41 | } else if(type === "[object Array]") { |
| 42 | if(context.length > 0) { |
| 43 | for(var i=0, j=context.length; i<j; i++) { |
| 44 | ret = ret + fn(context[i]); |
| 45 | } |
| 46 | } else { |
| 47 | ret = inverse(this); |
| 48 | } |
| 49 | return ret; |
| 50 | } else { |
| 51 | return fn(context); |
| 52 | } |
| 53 | }); |
| 54 | |
| 55 | Handlebars.registerHelper('each', function(context, options) { |
| 56 | var fn = options.fn, inverse = options.inverse; |
| 57 | var ret = ""; |
| 58 | |
| 59 | if(context && context.length > 0) { |
| 60 | for(var i=0, j=context.length; i<j; i++) { |
| 61 | ret = ret + fn(context[i]); |
| 62 | } |
| 63 | } else { |
| 64 | ret = inverse(this); |
| 65 | } |
| 66 | return ret; |
| 67 | }); |
| 68 | |
| 69 | Handlebars.registerHelper('if', function(context, options) { |
| 70 | var type = toString.call(context); |
| 71 | if(type === functionType) { context = context.call(this); } |
| 72 | |
| 73 | if(!context || Handlebars.Utils.isEmpty(context)) { |
| 74 | return options.inverse(this); |
| 75 | } else { |
| 76 | return options.fn(this); |
| 77 | } |
| 78 | }); |
| 79 | |
| 80 | Handlebars.registerHelper('unless', function(context, options) { |
| 81 | var fn = options.fn, inverse = options.inverse; |
| 82 | options.fn = inverse; |
| 83 | options.inverse = fn; |
| 84 | |
| 85 | return Handlebars.helpers['if'].call(this, context, options); |
| 86 | }); |
| 87 | |
| 88 | Handlebars.registerHelper('with', function(context, options) { |
| 89 | return options.fn(context); |
| 90 | }); |
| 91 | |
| 92 | Handlebars.registerHelper('log', function(context) { |
| 93 | Handlebars.log(context); |
| 94 | }); |
| 95 | ; |
| 96 | // lib/handlebars/compiler/parser.js |
| 97 | /* Jison generated parser */ |
| 98 | var handlebars = (function(){ |
| 99 | |
| 100 | var parser = {trace: function trace() { }, |
| 101 | yy: {}, |
| 102 | symbols_: {"error":2,"root":3,"program":4,"EOF":5,"statements":6,"simpleInverse":7,"statement":8,"openInverse":9,"closeBlock":10,"openBlock":11,"mustache":12,"partial":13,"CONTENT":14,"COMMENT":15,"OPEN_BLOCK":16,"inMustache":17,"CLOSE":18,"OPEN_INVERSE":19,"OPEN_ENDBLOCK":20,"path":21,"OPEN":22,"OPEN_UNESCAPED":23,"OPEN_PARTIAL":24,"params":25,"hash":26,"param":27,"STRING":28,"INTEGER":29,"BOOLEAN":30,"hashSegments":31,"hashSegment":32,"ID":33,"EQUALS":34,"pathSegments":35,"SEP":36,"$accept":0,"$end":1}, |
| 103 | terminals_: {2:"error",5:"EOF",14:"CONTENT",15:"COMMENT",16:"OPEN_BLOCK",18:"CLOSE",19:"OPEN_INVERSE",20:"OPEN_ENDBLOCK",22:"OPEN",23:"OPEN_UNESCAPED",24:"OPEN_PARTIAL",28:"STRING",29:"INTEGER",30:"BOOLEAN",33:"ID",34:"EQUALS",36:"SEP"}, |
| 104 | productions_: [0,[3,2],[4,3],[4,1],[4,0],[6,1],[6,2],[8,3],[8,3],[8,1],[8,1],[8,1],[8,1],[11,3],[9,3],[10,3],[12,3],[12,3],[13,3],[13,4],[7,2],[17,3],[17,2],[17,2],[17,1],[25,2],[25,1],[27,1],[27,1],[27,1],[27,1],[26,1],[31,2],[31,1],[32,3],[32,3],[32,3],[32,3],[21,1],[35,3],[35,1]], |
| 105 | performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) { |
| 106 | |
| 107 | var $0 = $$.length - 1; |
| 108 | switch (yystate) { |
| 109 | case 1: return $$[$0-1]; |
| 110 | break; |
| 111 | case 2: this.$ = new yy.ProgramNode($$[$0-2], $$[$0]); |
| 112 | break; |
| 113 | case 3: this.$ = new yy.ProgramNode($$[$0]); |
| 114 | break; |
| 115 | case 4: this.$ = new yy.ProgramNode([]); |
| 116 | break; |
| 117 | case 5: this.$ = [$$[$0]]; |
| 118 | break; |
| 119 | case 6: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; |
| 120 | break; |
| 121 | case 7: this.$ = new yy.InverseNode($$[$0-2], $$[$0-1], $$[$0]); |
| 122 | break; |
| 123 | case 8: this.$ = new yy.BlockNode($$[$0-2], $$[$0-1], $$[$0]); |
| 124 | break; |
| 125 | case 9: this.$ = $$[$0]; |
| 126 | break; |
| 127 | case 10: this.$ = $$[$0]; |
| 128 | break; |
| 129 | case 11: this.$ = new yy.ContentNode($$[$0]); |
| 130 | break; |
| 131 | case 12: this.$ = new yy.CommentNode($$[$0]); |
| 132 | break; |
| 133 | case 13: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1]); |
| 134 | break; |
| 135 | case 14: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1]); |
| 136 | break; |
| 137 | case 15: this.$ = $$[$0-1]; |
| 138 | break; |
| 139 | case 16: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1]); |
| 140 | break; |
| 141 | case 17: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1], true); |
| 142 | break; |
| 143 | case 18: this.$ = new yy.PartialNode($$[$0-1]); |
| 144 | break; |
| 145 | case 19: this.$ = new yy.PartialNode($$[$0-2], $$[$0-1]); |
| 146 | break; |
| 147 | case 20: |
| 148 | break; |
| 149 | case 21: this.$ = [[$$[$0-2]].concat($$[$0-1]), $$[$0]]; |
| 150 | break; |
| 151 | case 22: this.$ = [[$$[$0-1]].concat($$[$0]), null]; |
| 152 | break; |
| 153 | case 23: this.$ = [[$$[$0-1]], $$[$0]]; |
| 154 | break; |
| 155 | case 24: this.$ = [[$$[$0]], null]; |
| 156 | break; |
| 157 | case 25: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; |
| 158 | break; |
| 159 | case 26: this.$ = [$$[$0]]; |
| 160 | break; |
| 161 | case 27: this.$ = $$[$0]; |
| 162 | break; |
| 163 | case 28: this.$ = new yy.StringNode($$[$0]); |
| 164 | break; |
| 165 | case 29: this.$ = new yy.IntegerNode($$[$0]); |
| 166 | break; |
| 167 | case 30: this.$ = new yy.BooleanNode($$[$0]); |
| 168 | break; |
| 169 | case 31: this.$ = new yy.HashNode($$[$0]); |
| 170 | break; |
| 171 | case 32: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; |
| 172 | break; |
| 173 | case 33: this.$ = [$$[$0]]; |
| 174 | break; |
| 175 | case 34: this.$ = [$$[$0-2], $$[$0]]; |
| 176 | break; |
| 177 | case 35: this.$ = [$$[$0-2], new yy.StringNode($$[$0])]; |
| 178 | break; |
| 179 | case 36: this.$ = [$$[$0-2], new yy.IntegerNode($$[$0])]; |
| 180 | break; |
| 181 | case 37: this.$ = [$$[$0-2], new yy.BooleanNode($$[$0])]; |
| 182 | break; |
| 183 | case 38: this.$ = new yy.IdNode($$[$0]); |
| 184 | break; |
| 185 | case 39: $$[$0-2].push($$[$0]); this.$ = $$[$0-2]; |
| 186 | break; |
| 187 | case 40: this.$ = [$$[$0]]; |
| 188 | break; |
| 189 | } |
| 190 | }, |
| 191 | table: [{3:1,4:2,5:[2,4],6:3,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],22:[1,13],23:[1,14],24:[1,15]},{1:[3]},{5:[1,16]},{5:[2,3],7:17,8:18,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,19],20:[2,3],22:[1,13],23:[1,14],24:[1,15]},{5:[2,5],14:[2,5],15:[2,5],16:[2,5],19:[2,5],20:[2,5],22:[2,5],23:[2,5],24:[2,5]},{4:20,6:3,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,4],22:[1,13],23:[1,14],24:[1,15]},{4:21,6:3,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,4],22:[1,13],23:[1,14],24:[1,15]},{5:[2,9],14:[2,9],15:[2,9],16:[2,9],19:[2,9],20:[2,9],22:[2,9],23:[2,9],24:[2,9]},{5:[2,10],14:[2,10],15:[2,10],16:[2,10],19:[2,10],20:[2,10],22:[2,10],23:[2,10],24:[2,10]},{5:[2,11],14:[2,11],15:[2,11],16:[2,11],19:[2,11],20:[2,11],22:[2,11],23:[2,11],24:[2,11]},{5:[2,12],14:[2,12],15:[2,12],16:[2,12],19:[2,12],20:[2,12],22:[2,12],23:[2,12],24:[2,12]},{17:22,21:23,33:[1,25],35:24},{17:26,21:23,33:[1,25],35:24},{17:27,21:23,33:[1,25],35:24},{17:28,21:23,33:[1,25],35:24},{21:29,33:[1,25],35:24},{1:[2,1]},{6:30,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],22:[1,13],23:[1,14],24:[1,15]},{5:[2,6],14:[2,6],15:[2,6],16:[2,6],19:[2,6],20:[2,6],22:[2,6],23:[2,6],24:[2,6]},{17:22,18:[1,31],21:23,33:[1,25],35:24},{10:32,20:[1,33]},{10:34,20:[1,33]},{18:[1,35]},{18:[2,24],21:40,25:36,26:37,27:38,28:[1,41],29:[1,42],30:[1,43],31:39,32:44,33:[1,45],35:24},{18:[2,38],28:[2,38],29:[2,38],30:[2,38],33:[2,38],36:[1,46]},{18:[2,40],28:[2,40],29:[2,40],30:[2,40],33:[2,40],36:[2,40]},{18:[1,47]},{18:[1,48]},{18:[1,49]},{18:[1,50],21:51,33:[1,25],35:24},{5:[2,2],8:18,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,2],22:[1,13],23:[1,14],24:[1,15]},{14:[2,20],15:[2,20],16:[2,20],19:[2,20],22:[2,20],23:[2,20],24:[2,20]},{5:[2,7],14:[2,7],15:[2,7],16:[2,7],19:[2,7],20:[2,7],22:[2,7],23:[2,7],24:[2,7]},{21:52,33:[1,25],35:24},{5:[2,8],14:[2,8],15:[2,8],16:[2,8],19:[2,8],20:[2,8],22:[2,8],23:[2,8],24:[2,8]},{14:[2,14],15:[2,14],16:[2,14],19:[2,14],20:[2,14],22:[2,14],23:[2,14],24:[2,14]},{18:[2,22],21:40,26:53,27:54,28:[1,41],29:[1,42],30:[1,43],31:39,32:44,33:[1,45],35:24},{18:[2,23]},{18:[2,26],28:[2,26],29:[2,26],30:[2,26],33:[2,26]},{18:[2,31],32:55,33:[1,56]},{18:[2,27],28:[2,27],29:[2,27],30:[2,27],33:[2,27]},{18:[2,28],28:[2,28],29:[2,28],30:[2,28],33:[2,28]},{18:[2,29],28:[2,29],29:[2,29],30:[2,29],33:[2,29]},{18:[2,30],28:[2,30],29:[2,30],30:[2,30],33:[2,30]},{18:[2,33],33:[2,33]},{18:[2,40],28:[2,40],29:[2,40],30:[2,40],33:[2,40],34:[1,57],36:[2,40]},{33:[1,58]},{14:[2,13],15:[2,13],16:[2,13],19:[2,13],20:[2,13],22:[2,13],23:[2,13],24:[2,13]},{5:[2,16],14:[2,16],15:[2,16],16:[2,16],19:[2,16],20:[2,16],22:[2,16],23:[2,16],24:[2,16]},{5:[2,17],14:[2,17],15:[2,17],16:[2,17],19:[2,17],20:[2,17],22:[2,17],23:[2,17],24:[2,17]},{5:[2,18],14:[2,18],15:[2,18],16:[2,18],19:[2,18],20:[2,18],22:[2,18],23:[2,18],24:[2,18]},{18:[1,59]},{18:[1,60]},{18:[2,21]},{18:[2,25],28:[2,25],29:[2,25],30:[2,25],33:[2,25]},{18:[2,32],33:[2,32]},{34:[1,57]},{21:61,28:[1,62],29:[1,63],30:[1,64],33:[1,25],35:24},{18:[2,39],28:[2,39],29:[2,39],30:[2,39],33:[2,39],36:[2,39]},{5:[2,19],14:[2,19],15:[2,19],16:[2,19],19:[2,19],20:[2,19],22:[2,19],23:[2,19],24:[2,19]},{5:[2,15],14:[2,15],15:[2,15],16:[2,15],19:[2,15],20:[2,15],22:[2,15],23:[2,15],24:[2,15]},{18:[2,34],33:[2,34]},{18:[2,35],33:[2,35]},{18:[2,36],33:[2,36]},{18:[2,37],33:[2,37]}], |
| 192 | defaultActions: {16:[2,1],37:[2,23],53:[2,21]}, |
| 193 | parseError: function parseError(str, hash) { |
| 194 | throw new Error(str); |
| 195 | }, |
| 196 | parse: function parse(input) { |
| 197 | var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1; |
| 198 | this.lexer.setInput(input); |
| 199 | this.lexer.yy = this.yy; |
| 200 | this.yy.lexer = this.lexer; |
| 201 | if (typeof this.lexer.yylloc == "undefined") |
| 202 | this.lexer.yylloc = {}; |
| 203 | var yyloc = this.lexer.yylloc; |
| 204 | lstack.push(yyloc); |
| 205 | if (typeof this.yy.parseError === "function") |
| 206 | this.parseError = this.yy.parseError; |
| 207 | function popStack(n) { |
| 208 | stack.length = stack.length - 2 * n; |
| 209 | vstack.length = vstack.length - n; |
| 210 | lstack.length = lstack.length - n; |
| 211 | } |
| 212 | function lex() { |
| 213 | var token; |
| 214 | token = self.lexer.lex() || 1; |
| 215 | if (typeof token !== "number") { |
| 216 | token = self.symbols_[token] || token; |
| 217 | } |
| 218 | return token; |
| 219 | } |
| 220 | var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected; |
| 221 | while (true) { |
| 222 | state = stack[stack.length - 1]; |
| 223 | if (this.defaultActions[state]) { |
| 224 | action = this.defaultActions[state]; |
| 225 | } else { |
| 226 | if (symbol == null) |
| 227 | symbol = lex(); |
| 228 | action = table[state] && table[state][symbol]; |
| 229 | } |
| 230 | if (typeof action === "undefined" || !action.length || !action[0]) { |
| 231 | if (!recovering) { |
| 232 | expected = []; |
| 233 | for (p in table[state]) |
| 234 | if (this.terminals_[p] && p > 2) { |
| 235 | expected.push("'" + this.terminals_[p] + "'"); |
| 236 | } |
| 237 | var errStr = ""; |
| 238 | if (this.lexer.showPosition) { |
| 239 | errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + this.terminals_[symbol] + "'"; |
| 240 | } else { |
| 241 | errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1?"end of input":"'" + (this.terminals_[symbol] || symbol) + "'"); |
| 242 | } |
| 243 | this.parseError(errStr, {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected}); |
| 244 | } |
| 245 | } |
| 246 | if (action[0] instanceof Array && action.length > 1) { |
| 247 | throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol); |
| 248 | } |
| 249 | switch (action[0]) { |
| 250 | case 1: |
| 251 | stack.push(symbol); |
| 252 | vstack.push(this.lexer.yytext); |
| 253 | lstack.push(this.lexer.yylloc); |
| 254 | stack.push(action[1]); |
| 255 | symbol = null; |
| 256 | if (!preErrorSymbol) { |
| 257 | yyleng = this.lexer.yyleng; |
| 258 | yytext = this.lexer.yytext; |
| 259 | yylineno = this.lexer.yylineno; |
| 260 | yyloc = this.lexer.yylloc; |
| 261 | if (recovering > 0) |
| 262 | recovering--; |
| 263 | } else { |
| 264 | symbol = preErrorSymbol; |
| 265 | preErrorSymbol = null; |
| 266 | } |
| 267 | break; |
| 268 | case 2: |
| 269 | len = this.productions_[action[1]][1]; |
| 270 | yyval.$ = vstack[vstack.length - len]; |
| 271 | 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}; |
| 272 | r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack); |
| 273 | if (typeof r !== "undefined") { |
| 274 | return r; |
| 275 | } |
| 276 | if (len) { |
| 277 | stack = stack.slice(0, -1 * len * 2); |
| 278 | vstack = vstack.slice(0, -1 * len); |
| 279 | lstack = lstack.slice(0, -1 * len); |
| 280 | } |
| 281 | stack.push(this.productions_[action[1]][0]); |
| 282 | vstack.push(yyval.$); |
| 283 | lstack.push(yyval._$); |
| 284 | newState = table[stack[stack.length - 2]][stack[stack.length - 1]]; |
| 285 | stack.push(newState); |
| 286 | break; |
| 287 | case 3: |
| 288 | return true; |
| 289 | } |
| 290 | } |
| 291 | return true; |
| 292 | } |
| 293 | };/* Jison generated lexer */ |
| 294 | var lexer = (function(){ |
| 295 | |
| 296 | var lexer = ({EOF:1, |
| 297 | parseError:function parseError(str, hash) { |
| 298 | if (this.yy.parseError) { |
| 299 | this.yy.parseError(str, hash); |
| 300 | } else { |
| 301 | throw new Error(str); |
| 302 | } |
| 303 | }, |
| 304 | setInput:function (input) { |
| 305 | this._input = input; |
| 306 | this._more = this._less = this.done = false; |
| 307 | this.yylineno = this.yyleng = 0; |
| 308 | this.yytext = this.matched = this.match = ''; |
| 309 | this.conditionStack = ['INITIAL']; |
| 310 | this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0}; |
| 311 | return this; |
| 312 | }, |
| 313 | input:function () { |
| 314 | var ch = this._input[0]; |
| 315 | this.yytext+=ch; |
| 316 | this.yyleng++; |
| 317 | this.match+=ch; |
| 318 | this.matched+=ch; |
| 319 | var lines = ch.match(/\n/); |
| 320 | if (lines) this.yylineno++; |
| 321 | this._input = this._input.slice(1); |
| 322 | return ch; |
| 323 | }, |
| 324 | unput:function (ch) { |
| 325 | this._input = ch + this._input; |
| 326 | return this; |
| 327 | }, |
| 328 | more:function () { |
| 329 | this._more = true; |
| 330 | return this; |
| 331 | }, |
| 332 | pastInput:function () { |
| 333 | var past = this.matched.substr(0, this.matched.length - this.match.length); |
| 334 | return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, ""); |
| 335 | }, |
| 336 | upcomingInput:function () { |
| 337 | var next = this.match; |
| 338 | if (next.length < 20) { |
| 339 | next += this._input.substr(0, 20-next.length); |
| 340 | } |
| 341 | return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, ""); |
| 342 | }, |
| 343 | showPosition:function () { |
| 344 | var pre = this.pastInput(); |
| 345 | var c = new Array(pre.length + 1).join("-"); |
| 346 | return pre + this.upcomingInput() + "\n" + c+"^"; |
| 347 | }, |
| 348 | next:function () { |
| 349 | if (this.done) { |
| 350 | return this.EOF; |
| 351 | } |
| 352 | if (!this._input) this.done = true; |
| 353 | |
| 354 | var token, |
| 355 | match, |
| 356 | col, |
| 357 | lines; |
| 358 | if (!this._more) { |
| 359 | this.yytext = ''; |
| 360 | this.match = ''; |
| 361 | } |
| 362 | var rules = this._currentRules(); |
| 363 | for (var i=0;i < rules.length; i++) { |
| 364 | match = this._input.match(this.rules[rules[i]]); |
| 365 | if (match) { |
| 366 | lines = match[0].match(/\n.*/g); |
| 367 | if (lines) this.yylineno += lines.length; |
| 368 | this.yylloc = {first_line: this.yylloc.last_line, |
| 369 | last_line: this.yylineno+1, |
| 370 | first_column: this.yylloc.last_column, |
| 371 | last_column: lines ? lines[lines.length-1].length-1 : this.yylloc.last_column + match[0].length}; |
| 372 | this.yytext += match[0]; |
| 373 | this.match += match[0]; |
| 374 | this.matches = match; |
| 375 | this.yyleng = this.yytext.length; |
| 376 | this._more = false; |
| 377 | this._input = this._input.slice(match[0].length); |
| 378 | this.matched += match[0]; |
| 379 | token = this.performAction.call(this, this.yy, this, rules[i],this.conditionStack[this.conditionStack.length-1]); |
| 380 | if (token) return token; |
| 381 | else return; |
| 382 | } |
| 383 | } |
| 384 | if (this._input === "") { |
| 385 | return this.EOF; |
| 386 | } else { |
| 387 | this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(), |
| 388 | {text: "", token: null, line: this.yylineno}); |
| 389 | } |
| 390 | }, |
| 391 | lex:function lex() { |
| 392 | var r = this.next(); |
| 393 | if (typeof r !== 'undefined') { |
| 394 | return r; |
| 395 | } else { |
| 396 | return this.lex(); |
| 397 | } |
| 398 | }, |
| 399 | begin:function begin(condition) { |
| 400 | this.conditionStack.push(condition); |
| 401 | }, |
| 402 | popState:function popState() { |
| 403 | return this.conditionStack.pop(); |
| 404 | }, |
| 405 | _currentRules:function _currentRules() { |
| 406 | return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules; |
| 407 | }, |
| 408 | topState:function () { |
| 409 | return this.conditionStack[this.conditionStack.length-2]; |
| 410 | }, |
| 411 | pushState:function begin(condition) { |
| 412 | this.begin(condition); |
| 413 | }}); |
| 414 | lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) { |
| 415 | |
| 416 | var YYSTATE=YY_START; |
| 417 | switch($avoiding_name_collisions) { |
| 418 | case 0: |
| 419 | if(yy_.yytext.slice(-1) !== "\\") this.begin("mu"); |
| 420 | if(yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0,yy_.yyleng-1), this.begin("emu"); |
| 421 | if(yy_.yytext) return 14; |
| 422 | |
| 423 | break; |
| 424 | case 1: return 14; |
| 425 | break; |
| 426 | case 2: this.popState(); return 14; |
| 427 | break; |
| 428 | case 3: return 24; |
| 429 | break; |
| 430 | case 4: return 16; |
| 431 | break; |
| 432 | case 5: return 20; |
| 433 | break; |
| 434 | case 6: return 19; |
| 435 | break; |
| 436 | case 7: return 19; |
| 437 | break; |
| 438 | case 8: return 23; |
| 439 | break; |
| 440 | case 9: return 23; |
| 441 | break; |
| 442 | case 10: yy_.yytext = yy_.yytext.substr(3,yy_.yyleng-5); this.popState(); return 15; |
| 443 | break; |
| 444 | case 11: return 22; |
| 445 | break; |
| 446 | case 12: return 34; |
| 447 | break; |
| 448 | case 13: return 33; |
| 449 | break; |
| 450 | case 14: return 33; |
| 451 | break; |
| 452 | case 15: return 36; |
| 453 | break; |
| 454 | case 16: /*ignore whitespace*/ |
| 455 | break; |
| 456 | case 17: this.popState(); return 18; |
| 457 | break; |
| 458 | case 18: this.popState(); return 18; |
| 459 | break; |
| 460 | case 19: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\"/g,'"'); return 28; |
| 461 | break; |
| 462 | case 20: return 30; |
| 463 | break; |
| 464 | case 21: return 30; |
| 465 | break; |
| 466 | case 22: return 29; |
| 467 | break; |
| 468 | case 23: return 33; |
| 469 | break; |
| 470 | case 24: yy_.yytext = yy_.yytext.substr(1, yy_.yyleng-2); return 33; |
| 471 | break; |
| 472 | case 25: return 'INVALID'; |
| 473 | break; |
| 474 | case 26: return 5; |
| 475 | break; |
| 476 | } |
| 477 | }; |
| 478 | lexer.rules = [/^[^\x00]*?(?=(\{\{))/,/^[^\x00]+/,/^[^\x00]{2,}?(?=(\{\{))/,/^\{\{>/,/^\{\{#/,/^\{\{\//,/^\{\{\^/,/^\{\{\s*else\b/,/^\{\{\{/,/^\{\{&/,/^\{\{![\s\S]*?\}\}/,/^\{\{/,/^=/,/^\.(?=[} ])/,/^\.\./,/^[\/.]/,/^\s+/,/^\}\}\}/,/^\}\}/,/^"(\\["]|[^"])*"/,/^true(?=[}\s])/,/^false(?=[}\s])/,/^[0-9]+(?=[}\s])/,/^[a-zA-Z0-9_$-]+(?=[=}\s\/.])/,/^\[[^\]]*\]/,/^./,/^$/]; |
| 479 | lexer.conditions = {"mu":{"rules":[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26],"inclusive":false},"emu":{"rules":[2],"inclusive":false},"INITIAL":{"rules":[0,1,26],"inclusive":true}};return lexer;})(); |
| 480 | parser.lexer = lexer; |
| 481 | return parser; |
| 482 | })(); |
| 483 | if (typeof require !== 'undefined' && typeof exports !== 'undefined') { |
| 484 | exports.parser = handlebars; |
| 485 | exports.parse = function () { return handlebars.parse.apply(handlebars, arguments); }; |
| 486 | exports.main = function commonjsMain(args) { |
| 487 | if (!args[1]) |
| 488 | throw new Error('Usage: '+args[0]+' FILE'); |
| 489 | if (typeof process !== 'undefined') { |
| 490 | var source = require('fs').readFileSync(require('path').join(process.cwd(), args[1]), "utf8"); |
| 491 | } else { |
| 492 | var cwd = require("file").path(require("file").cwd()); |
| 493 | var source = cwd.join(args[1]).read({charset: "utf-8"}); |
| 494 | } |
| 495 | return exports.parser.parse(source); |
| 496 | }; |
| 497 | if (typeof module !== 'undefined' && require.main === module) { |
| 498 | exports.main(typeof process !== 'undefined' ? process.argv.slice(1) : require("system").args); |
| 499 | } |
| 500 | }; |
| 501 | ; |
| 502 | // lib/handlebars/compiler/base.js |
| 503 | Handlebars.Parser = handlebars; |
| 504 | |
| 505 | Handlebars.parse = function(string) { |
| 506 | Handlebars.Parser.yy = Handlebars.AST; |
| 507 | return Handlebars.Parser.parse(string); |
| 508 | }; |
| 509 | |
| 510 | Handlebars.print = function(ast) { |
| 511 | return new Handlebars.PrintVisitor().accept(ast); |
| 512 | }; |
| 513 | |
| 514 | Handlebars.logger = { |
| 515 | DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3, |
| 516 | |
| 517 | // override in the host environment |
| 518 | log: function(level, str) {} |
| 519 | }; |
| 520 | |
| 521 | Handlebars.log = function(level, str) { Handlebars.logger.log(level, str); }; |
| 522 | ; |
| 523 | // lib/handlebars/compiler/ast.js |
| 524 | (function() { |
| 525 | |
| 526 | Handlebars.AST = {}; |
| 527 | |
| 528 | Handlebars.AST.ProgramNode = function(statements, inverse) { |
| 529 | this.type = "program"; |
| 530 | this.statements = statements; |
| 531 | if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); } |
| 532 | }; |
| 533 | |
| 534 | Handlebars.AST.MustacheNode = function(params, hash, unescaped) { |
| 535 | this.type = "mustache"; |
| 536 | this.id = params[0]; |
| 537 | this.params = params.slice(1); |
| 538 | this.hash = hash; |
| 539 | this.escaped = !unescaped; |
| 540 | }; |
| 541 | |
| 542 | Handlebars.AST.PartialNode = function(id, context) { |
| 543 | this.type = "partial"; |
| 544 | |
| 545 | // TODO: disallow complex IDs |
| 546 | |
| 547 | this.id = id; |
| 548 | this.context = context; |
| 549 | }; |
| 550 | |
| 551 | var verifyMatch = function(open, close) { |
| 552 | if(open.original !== close.original) { |
| 553 | throw new Handlebars.Exception(open.original + " doesn't match " + close.original); |
| 554 | } |
| 555 | }; |
| 556 | |
| 557 | Handlebars.AST.BlockNode = function(mustache, program, close) { |
| 558 | verifyMatch(mustache.id, close); |
| 559 | this.type = "block"; |
| 560 | this.mustache = mustache; |
| 561 | this.program = program; |
| 562 | }; |
| 563 | |
| 564 | Handlebars.AST.InverseNode = function(mustache, program, close) { |
| 565 | verifyMatch(mustache.id, close); |
| 566 | this.type = "inverse"; |
| 567 | this.mustache = mustache; |
| 568 | this.program = program; |
| 569 | }; |
| 570 | |
| 571 | Handlebars.AST.ContentNode = function(string) { |
| 572 | this.type = "content"; |
| 573 | this.string = string; |
| 574 | }; |
| 575 | |
| 576 | Handlebars.AST.HashNode = function(pairs) { |
| 577 | this.type = "hash"; |
| 578 | this.pairs = pairs; |
| 579 | }; |
| 580 | |
| 581 | Handlebars.AST.IdNode = function(parts) { |
| 582 | this.type = "ID"; |
| 583 | this.original = parts.join("."); |
| 584 | |
| 585 | var dig = [], depth = 0; |
| 586 | |
| 587 | for(var i=0,l=parts.length; i<l; i++) { |
| 588 | var part = parts[i]; |
| 589 | |
| 590 | if(part === "..") { depth++; } |
| 591 | else if(part === "." || part === "this") { this.isScoped = true; } |
| 592 | else { dig.push(part); } |
| 593 | } |
| 594 | |
| 595 | this.parts = dig; |
| 596 | this.string = dig.join('.'); |
| 597 | this.depth = depth; |
| 598 | this.isSimple = (dig.length === 1) && (depth === 0); |
| 599 | }; |
| 600 | |
| 601 | Handlebars.AST.StringNode = function(string) { |
| 602 | this.type = "STRING"; |
| 603 | this.string = string; |
| 604 | }; |
| 605 | |
| 606 | Handlebars.AST.IntegerNode = function(integer) { |
| 607 | this.type = "INTEGER"; |
| 608 | this.integer = integer; |
| 609 | }; |
| 610 | |
| 611 | Handlebars.AST.BooleanNode = function(bool) { |
| 612 | this.type = "BOOLEAN"; |
| 613 | this.bool = bool; |
| 614 | }; |
| 615 | |
| 616 | Handlebars.AST.CommentNode = function(comment) { |
| 617 | this.type = "comment"; |
| 618 | this.comment = comment; |
| 619 | }; |
| 620 | |
| 621 | })();; |
| 622 | // lib/handlebars/utils.js |
| 623 | Handlebars.Exception = function(message) { |
| 624 | var tmp = Error.prototype.constructor.apply(this, arguments); |
| 625 | |
| 626 | for (var p in tmp) { |
| 627 | if (tmp.hasOwnProperty(p)) { this[p] = tmp[p]; } |
| 628 | } |
| 629 | |
| 630 | this.message = tmp.message; |
| 631 | }; |
| 632 | Handlebars.Exception.prototype = new Error; |
| 633 | |
| 634 | // Build out our basic SafeString type |
| 635 | Handlebars.SafeString = function(string) { |
| 636 | this.string = string; |
| 637 | }; |
| 638 | Handlebars.SafeString.prototype.toString = function() { |
| 639 | return this.string.toString(); |
| 640 | }; |
| 641 | |
| 642 | (function() { |
| 643 | var escape = { |
| 644 | "<": "<", |
| 645 | ">": ">", |
| 646 | '"': """, |
| 647 | "'": "'", |
| 648 | "`": "`" |
| 649 | }; |
| 650 | |
| 651 | var badChars = /&(?!\w+;)|[<>"'`]/g; |
| 652 | var possible = /[&<>"'`]/; |
| 653 | |
| 654 | var escapeChar = function(chr) { |
| 655 | return escape[chr] || "&"; |
| 656 | }; |
| 657 | |
| 658 | Handlebars.Utils = { |
| 659 | escapeExpression: function(string) { |
| 660 | // don't escape SafeStrings, since they're already safe |
| 661 | if (string instanceof Handlebars.SafeString) { |
| 662 | return string.toString(); |
| 663 | } else if (string == null || string === false) { |
| 664 | return ""; |
| 665 | } |
| 666 | |
| 667 | if(!possible.test(string)) { return string; } |
| 668 | return string.replace(badChars, escapeChar); |
| 669 | }, |
| 670 | |
| 671 | isEmpty: function(value) { |
| 672 | if (typeof value === "undefined") { |
| 673 | return true; |
| 674 | } else if (value === null) { |
| 675 | return true; |
| 676 | } else if (value === false) { |
| 677 | return true; |
| 678 | } else if(Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) { |
| 679 | return true; |
| 680 | } else { |
| 681 | return false; |
| 682 | } |
| 683 | } |
| 684 | }; |
| 685 | })();; |
| 686 | // lib/handlebars/compiler/compiler.js |
| 687 | Handlebars.Compiler = function() {}; |
| 688 | Handlebars.JavaScriptCompiler = function() {}; |
| 689 | |
| 690 | (function(Compiler, JavaScriptCompiler) { |
| 691 | Compiler.OPCODE_MAP = { |
| 692 | appendContent: 1, |
| 693 | getContext: 2, |
| 694 | lookupWithHelpers: 3, |
| 695 | lookup: 4, |
| 696 | append: 5, |
| 697 | invokeMustache: 6, |
| 698 | appendEscaped: 7, |
| 699 | pushString: 8, |
| 700 | truthyOrFallback: 9, |
| 701 | functionOrFallback: 10, |
| 702 | invokeProgram: 11, |
| 703 | invokePartial: 12, |
| 704 | push: 13, |
| 705 | assignToHash: 15, |
| 706 | pushStringParam: 16 |
| 707 | }; |
| 708 | |
| 709 | Compiler.MULTI_PARAM_OPCODES = { |
| 710 | appendContent: 1, |
| 711 | getContext: 1, |
| 712 | lookupWithHelpers: 2, |
| 713 | lookup: 1, |
| 714 | invokeMustache: 3, |
| 715 | pushString: 1, |
| 716 | truthyOrFallback: 1, |
| 717 | functionOrFallback: 1, |
| 718 | invokeProgram: 3, |
| 719 | invokePartial: 1, |
| 720 | push: 1, |
| 721 | assignToHash: 1, |
| 722 | pushStringParam: 1 |
| 723 | }; |
| 724 | |
| 725 | Compiler.DISASSEMBLE_MAP = {}; |
| 726 | |
| 727 | for(var prop in Compiler.OPCODE_MAP) { |
| 728 | var value = Compiler.OPCODE_MAP[prop]; |
| 729 | Compiler.DISASSEMBLE_MAP[value] = prop; |
| 730 | } |
| 731 | |
| 732 | Compiler.multiParamSize = function(code) { |
| 733 | return Compiler.MULTI_PARAM_OPCODES[Compiler.DISASSEMBLE_MAP[code]]; |
| 734 | }; |
| 735 | |
| 736 | Compiler.prototype = { |
| 737 | compiler: Compiler, |
| 738 | |
| 739 | disassemble: function() { |
| 740 | var opcodes = this.opcodes, opcode, nextCode; |
| 741 | var out = [], str, name, value; |
| 742 | |
| 743 | for(var i=0, l=opcodes.length; i<l; i++) { |
| 744 | opcode = opcodes[i]; |
| 745 | |
| 746 | if(opcode === 'DECLARE') { |
| 747 | name = opcodes[++i]; |
| 748 | value = opcodes[++i]; |
| 749 | out.push("DECLARE " + name + " = " + value); |
| 750 | } else { |
| 751 | str = Compiler.DISASSEMBLE_MAP[opcode]; |
| 752 | |
| 753 | var extraParams = Compiler.multiParamSize(opcode); |
| 754 | var codes = []; |
| 755 | |
| 756 | for(var j=0; j<extraParams; j++) { |
| 757 | nextCode = opcodes[++i]; |
| 758 | |
| 759 | if(typeof nextCode === "string") { |
| 760 | nextCode = "\"" + nextCode.replace("\n", "\\n") + "\""; |
| 761 | } |
| 762 | |
| 763 | codes.push(nextCode); |
| 764 | } |
| 765 | |
| 766 | str = str + " " + codes.join(" "); |
| 767 | |
| 768 | out.push(str); |
| 769 | } |
| 770 | } |
| 771 | |
| 772 | return out.join("\n"); |
| 773 | }, |
| 774 | |
| 775 | guid: 0, |
| 776 | |
| 777 | compile: function(program, options) { |
| 778 | this.children = []; |
| 779 | this.depths = {list: []}; |
| 780 | this.options = options; |
| 781 | |
| 782 | // These changes will propagate to the other compiler components |
| 783 | var knownHelpers = this.options.knownHelpers; |
| 784 | this.options.knownHelpers = { |
| 785 | 'helperMissing': true, |
| 786 | 'blockHelperMissing': true, |
| 787 | 'each': true, |
| 788 | 'if': true, |
| 789 | 'unless': true, |
| 790 | 'with': true, |
| 791 | 'log': true |
| 792 | }; |
| 793 | if (knownHelpers) { |
| 794 | for (var name in knownHelpers) { |
| 795 | this.options.knownHelpers[name] = knownHelpers[name]; |
| 796 | } |
| 797 | } |
| 798 | |
| 799 | return this.program(program); |
| 800 | }, |
| 801 | |
| 802 | accept: function(node) { |
| 803 | return this[node.type](node); |
| 804 | }, |
| 805 | |
| 806 | program: function(program) { |
| 807 | var statements = program.statements, statement; |
| 808 | this.opcodes = []; |
| 809 | |
| 810 | for(var i=0, l=statements.length; i<l; i++) { |
| 811 | statement = statements[i]; |
| 812 | this[statement.type](statement); |
| 813 | } |
| 814 | this.isSimple = l === 1; |
| 815 | |
| 816 | this.depths.list = this.depths.list.sort(function(a, b) { |
| 817 | return a - b; |
| 818 | }); |
| 819 | |
| 820 | return this; |
| 821 | }, |
| 822 | |
| 823 | compileProgram: function(program) { |
| 824 | var result = new this.compiler().compile(program, this.options); |
| 825 | var guid = this.guid++; |
| 826 | |
| 827 | this.usePartial = this.usePartial || result.usePartial; |
| 828 | |
| 829 | this.children[guid] = result; |
| 830 | |
| 831 | for(var i=0, l=result.depths.list.length; i<l; i++) { |
| 832 | depth = result.depths.list[i]; |
| 833 | |
| 834 | if(depth < 2) { continue; } |
| 835 | else { this.addDepth(depth - 1); } |
| 836 | } |
| 837 | |
| 838 | return guid; |
| 839 | }, |
| 840 | |
| 841 | block: function(block) { |
| 842 | var mustache = block.mustache; |
| 843 | var depth, child, inverse, inverseGuid; |
| 844 | |
| 845 | var params = this.setupStackForMustache(mustache); |
| 846 | |
| 847 | var programGuid = this.compileProgram(block.program); |
| 848 | |
| 849 | if(block.program.inverse) { |
| 850 | inverseGuid = this.compileProgram(block.program.inverse); |
| 851 | this.declare('inverse', inverseGuid); |
| 852 | } |
| 853 | |
| 854 | this.opcode('invokeProgram', programGuid, params.length, !!mustache.hash); |
| 855 | this.declare('inverse', null); |
| 856 | this.opcode('append'); |
| 857 | }, |
| 858 | |
| 859 | inverse: function(block) { |
| 860 | var params = this.setupStackForMustache(block.mustache); |
| 861 | |
| 862 | var programGuid = this.compileProgram(block.program); |
| 863 | |
| 864 | this.declare('inverse', programGuid); |
| 865 | |
| 866 | this.opcode('invokeProgram', null, params.length, !!block.mustache.hash); |
| 867 | this.declare('inverse', null); |
| 868 | this.opcode('append'); |
| 869 | }, |
| 870 | |
| 871 | hash: function(hash) { |
| 872 | var pairs = hash.pairs, pair, val; |
| 873 | |
| 874 | this.opcode('push', '{}'); |
| 875 | |
| 876 | for(var i=0, l=pairs.length; i<l; i++) { |
| 877 | pair = pairs[i]; |
| 878 | val = pair[1]; |
| 879 | |
| 880 | this.accept(val); |
| 881 | this.opcode('assignToHash', pair[0]); |
| 882 | } |
| 883 | }, |
| 884 | |
| 885 | partial: function(partial) { |
| 886 | var id = partial.id; |
| 887 | this.usePartial = true; |
| 888 | |
| 889 | if(partial.context) { |
| 890 | this.ID(partial.context); |
| 891 | } else { |
| 892 | this.opcode('push', 'depth0'); |
| 893 | } |
| 894 | |
| 895 | this.opcode('invokePartial', id.original); |
| 896 | this.opcode('append'); |
| 897 | }, |
| 898 | |
| 899 | content: function(content) { |
| 900 | this.opcode('appendContent', content.string); |
| 901 | }, |
| 902 | |
| 903 | mustache: function(mustache) { |
| 904 | var params = this.setupStackForMustache(mustache); |
| 905 | |
| 906 | this.opcode('invokeMustache', params.length, mustache.id.original, !!mustache.hash); |
| 907 | |
| 908 | if(mustache.escaped && !this.options.noEscape) { |
| 909 | this.opcode('appendEscaped'); |
| 910 | } else { |
| 911 | this.opcode('append'); |
| 912 | } |
| 913 | }, |
| 914 | |
| 915 | ID: function(id) { |
| 916 | this.addDepth(id.depth); |
| 917 | |
| 918 | this.opcode('getContext', id.depth); |
| 919 | |
| 920 | this.opcode('lookupWithHelpers', id.parts[0] || null, id.isScoped || false); |
| 921 | |
| 922 | for(var i=1, l=id.parts.length; i<l; i++) { |
| 923 | this.opcode('lookup', id.parts[i]); |
| 924 | } |
| 925 | }, |
| 926 | |
| 927 | STRING: function(string) { |
| 928 | this.opcode('pushString', string.string); |
| 929 | }, |
| 930 | |
| 931 | INTEGER: function(integer) { |
| 932 | this.opcode('push', integer.integer); |
| 933 | }, |
| 934 | |
| 935 | BOOLEAN: function(bool) { |
| 936 | this.opcode('push', bool.bool); |
| 937 | }, |
| 938 | |
| 939 | comment: function() {}, |
| 940 | |
| 941 | // HELPERS |
| 942 | pushParams: function(params) { |
| 943 | var i = params.length, param; |
| 944 | |
| 945 | while(i--) { |
| 946 | param = params[i]; |
| 947 | |
| 948 | if(this.options.stringParams) { |
| 949 | if(param.depth) { |
| 950 | this.addDepth(param.depth); |
| 951 | } |
| 952 | |
| 953 | this.opcode('getContext', param.depth || 0); |
| 954 | this.opcode('pushStringParam', param.string); |
| 955 | } else { |
| 956 | this[param.type](param); |
| 957 | } |
| 958 | } |
| 959 | }, |
| 960 | |
| 961 | opcode: function(name, val1, val2, val3) { |
| 962 | this.opcodes.push(Compiler.OPCODE_MAP[name]); |
| 963 | if(val1 !== undefined) { this.opcodes.push(val1); } |
| 964 | if(val2 !== undefined) { this.opcodes.push(val2); } |
| 965 | if(val3 !== undefined) { this.opcodes.push(val3); } |
| 966 | }, |
| 967 | |
| 968 | declare: function(name, value) { |
| 969 | this.opcodes.push('DECLARE'); |
| 970 | this.opcodes.push(name); |
| 971 | this.opcodes.push(value); |
| 972 | }, |
| 973 | |
| 974 | addDepth: function(depth) { |
| 975 | if(depth === 0) { return; } |
| 976 | |
| 977 | if(!this.depths[depth]) { |
| 978 | this.depths[depth] = true; |
| 979 | this.depths.list.push(depth); |
| 980 | } |
| 981 | }, |
| 982 | |
| 983 | setupStackForMustache: function(mustache) { |
| 984 | var params = mustache.params; |
| 985 | |
| 986 | this.pushParams(params); |
| 987 | |
| 988 | if(mustache.hash) { |
| 989 | this.hash(mustache.hash); |
| 990 | } |
| 991 | |
| 992 | this.ID(mustache.id); |
| 993 | |
| 994 | return params; |
| 995 | } |
| 996 | }; |
| 997 | |
| 998 | JavaScriptCompiler.prototype = { |
| 999 | // PUBLIC API: You can override these methods in a subclass to provide |
| 1000 | // alternative compiled forms for name lookup and buffering semantics |
| 1001 | nameLookup: function(parent, name, type) { |
| 1002 | if (/^[0-9]+$/.test(name)) { |
| 1003 | return parent + "[" + name + "]"; |
| 1004 | } else if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) { |
| 1005 | return parent + "." + name; |
| 1006 | } |
| 1007 | else { |
| 1008 | return parent + "['" + name + "']"; |
| 1009 | } |
| 1010 | }, |
| 1011 | |
| 1012 | appendToBuffer: function(string) { |
| 1013 | if (this.environment.isSimple) { |
| 1014 | return "return " + string + ";"; |
| 1015 | } else { |
| 1016 | return "buffer += " + string + ";"; |
| 1017 | } |
| 1018 | }, |
| 1019 | |
| 1020 | initializeBuffer: function() { |
| 1021 | return this.quotedString(""); |
| 1022 | }, |
| 1023 | |
| 1024 | namespace: "Handlebars", |
| 1025 | // END PUBLIC API |
| 1026 | |
| 1027 | compile: function(environment, options, context, asObject) { |
| 1028 | this.environment = environment; |
| 1029 | this.options = options || {}; |
| 1030 | |
| 1031 | this.name = this.environment.name; |
| 1032 | this.isChild = !!context; |
| 1033 | this.context = context || { |
| 1034 | programs: [], |
| 1035 | aliases: { self: 'this' }, |
| 1036 | registers: {list: []} |
| 1037 | }; |
| 1038 | |
| 1039 | this.preamble(); |
| 1040 | |
| 1041 | this.stackSlot = 0; |
| 1042 | this.stackVars = []; |
| 1043 | |
| 1044 | this.compileChildren(environment, options); |
| 1045 | |
| 1046 | var opcodes = environment.opcodes, opcode; |
| 1047 | |
| 1048 | this.i = 0; |
| 1049 | |
| 1050 | for(l=opcodes.length; this.i<l; this.i++) { |
| 1051 | opcode = this.nextOpcode(0); |
| 1052 | |
| 1053 | if(opcode[0] === 'DECLARE') { |
| 1054 | this.i = this.i + 2; |
| 1055 | this[opcode[1]] = opcode[2]; |
| 1056 | } else { |
| 1057 | this.i = this.i + opcode[1].length; |
| 1058 | this[opcode[0]].apply(this, opcode[1]); |
| 1059 | } |
| 1060 | } |
| 1061 | |
| 1062 | return this.createFunctionContext(asObject); |
| 1063 | }, |
| 1064 | |
| 1065 | nextOpcode: function(n) { |
| 1066 | var opcodes = this.environment.opcodes, opcode = opcodes[this.i + n], name, val; |
| 1067 | var extraParams, codes; |
| 1068 | |
| 1069 | if(opcode === 'DECLARE') { |
| 1070 | name = opcodes[this.i + 1]; |
| 1071 | val = opcodes[this.i + 2]; |
| 1072 | return ['DECLARE', name, val]; |
| 1073 | } else { |
| 1074 | name = Compiler.DISASSEMBLE_MAP[opcode]; |
| 1075 | |
| 1076 | extraParams = Compiler.multiParamSize(opcode); |
| 1077 | codes = []; |
| 1078 | |
| 1079 | for(var j=0; j<extraParams; j++) { |
| 1080 | codes.push(opcodes[this.i + j + 1 + n]); |
| 1081 | } |
| 1082 | |
| 1083 | return [name, codes]; |
| 1084 | } |
| 1085 | }, |
| 1086 | |
| 1087 | eat: function(opcode) { |
| 1088 | this.i = this.i + opcode.length; |
| 1089 | }, |
| 1090 | |
| 1091 | preamble: function() { |
| 1092 | var out = []; |
| 1093 | |
| 1094 | // this register will disambiguate helper lookup from finding a function in |
| 1095 | // a context. This is necessary for mustache compatibility, which requires |
| 1096 | // that context functions in blocks are evaluated by blockHelperMissing, and |
| 1097 | // then proceed as if the resulting value was provided to blockHelperMissing. |
| 1098 | this.useRegister('foundHelper'); |
| 1099 | |
| 1100 | if (!this.isChild) { |
| 1101 | var namespace = this.namespace; |
| 1102 | var copies = "helpers = helpers || " + namespace + ".helpers;"; |
| 1103 | if(this.environment.usePartial) { copies = copies + " partials = partials || " + namespace + ".partials;"; } |
| 1104 | out.push(copies); |
| 1105 | } else { |
| 1106 | out.push(''); |
| 1107 | } |
| 1108 | |
| 1109 | if (!this.environment.isSimple) { |
| 1110 | out.push(", buffer = " + this.initializeBuffer()); |
| 1111 | } else { |
| 1112 | out.push(""); |
| 1113 | } |
| 1114 | |
| 1115 | // track the last context pushed into place to allow skipping the |
| 1116 | // getContext opcode when it would be a noop |
| 1117 | this.lastContext = 0; |
| 1118 | this.source = out; |
| 1119 | }, |
| 1120 | |
| 1121 | createFunctionContext: function(asObject) { |
| 1122 | var locals = this.stackVars; |
| 1123 | if (!this.isChild) { |
| 1124 | locals = locals.concat(this.context.registers.list); |
| 1125 | } |
| 1126 | |
| 1127 | if(locals.length > 0) { |
| 1128 | this.source[1] = this.source[1] + ", " + locals.join(", "); |
| 1129 | } |
| 1130 | |
| 1131 | // Generate minimizer alias mappings |
| 1132 | if (!this.isChild) { |
| 1133 | var aliases = []; |
| 1134 | for (var alias in this.context.aliases) { |
| 1135 | this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias]; |
| 1136 | } |
| 1137 | } |
| 1138 | |
| 1139 | if (this.source[1]) { |
| 1140 | this.source[1] = "var " + this.source[1].substring(2) + ";"; |
| 1141 | } |
| 1142 | |
| 1143 | // Merge children |
| 1144 | if (!this.isChild) { |
| 1145 | this.source[1] += '\n' + this.context.programs.join('\n') + '\n'; |
| 1146 | } |
| 1147 | |
| 1148 | if (!this.environment.isSimple) { |
| 1149 | this.source.push("return buffer;"); |
| 1150 | } |
| 1151 | |
| 1152 | var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"]; |
| 1153 | |
| 1154 | for(var i=0, l=this.environment.depths.list.length; i<l; i++) { |
| 1155 | params.push("depth" + this.environment.depths.list[i]); |
| 1156 | } |
| 1157 | |
| 1158 | if (asObject) { |
| 1159 | params.push(this.source.join("\n ")); |
| 1160 | |
| 1161 | return Function.apply(this, params); |
| 1162 | } else { |
| 1163 | var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n ' + this.source.join("\n ") + '}'; |
| 1164 | Handlebars.log(Handlebars.logger.DEBUG, functionSource + "\n\n"); |
| 1165 | return functionSource; |
| 1166 | } |
| 1167 | }, |
| 1168 | |
| 1169 | appendContent: function(content) { |
| 1170 | this.source.push(this.appendToBuffer(this.quotedString(content))); |
| 1171 | }, |
| 1172 | |
| 1173 | append: function() { |
| 1174 | var local = this.popStack(); |
| 1175 | this.source.push("if(" + local + " || " + local + " === 0) { " + this.appendToBuffer(local) + " }"); |
| 1176 | if (this.environment.isSimple) { |
| 1177 | this.source.push("else { " + this.appendToBuffer("''") + " }"); |
| 1178 | } |
| 1179 | }, |
| 1180 | |
| 1181 | appendEscaped: function() { |
| 1182 | var opcode = this.nextOpcode(1), extra = ""; |
| 1183 | this.context.aliases.escapeExpression = 'this.escapeExpression'; |
| 1184 | |
| 1185 | if(opcode[0] === 'appendContent') { |
| 1186 | extra = " + " + this.quotedString(opcode[1][0]); |
| 1187 | this.eat(opcode); |
| 1188 | } |
| 1189 | |
| 1190 | this.source.push(this.appendToBuffer("escapeExpression(" + this.popStack() + ")" + extra)); |
| 1191 | }, |
| 1192 | |
| 1193 | getContext: function(depth) { |
| 1194 | if(this.lastContext !== depth) { |
| 1195 | this.lastContext = depth; |
| 1196 | } |
| 1197 | }, |
| 1198 | |
| 1199 | lookupWithHelpers: function(name, isScoped) { |
| 1200 | if(name) { |
| 1201 | var topStack = this.nextStack(); |
| 1202 | |
| 1203 | this.usingKnownHelper = false; |
| 1204 | |
| 1205 | var toPush; |
| 1206 | if (!isScoped && this.options.knownHelpers[name]) { |
| 1207 | toPush = topStack + " = " + this.nameLookup('helpers', name, 'helper'); |
| 1208 | this.usingKnownHelper = true; |
| 1209 | } else if (isScoped || this.options.knownHelpersOnly) { |
| 1210 | toPush = topStack + " = " + this.nameLookup('depth' + this.lastContext, name, 'context'); |
| 1211 | } else { |
| 1212 | this.register('foundHelper', this.nameLookup('helpers', name, 'helper')); |
| 1213 | toPush = topStack + " = foundHelper || " + this.nameLookup('depth' + this.lastContext, name, 'context'); |
| 1214 | } |
| 1215 | |
| 1216 | toPush += ';'; |
| 1217 | this.source.push(toPush); |
| 1218 | } else { |
| 1219 | this.pushStack('depth' + this.lastContext); |
| 1220 | } |
| 1221 | }, |
| 1222 | |
| 1223 | lookup: function(name) { |
| 1224 | var topStack = this.topStack(); |
| 1225 | this.source.push(topStack + " = (" + topStack + " === null || " + topStack + " === undefined || " + topStack + " === false ? " + |
| 1226 | topStack + " : " + this.nameLookup(topStack, name, 'context') + ");"); |
| 1227 | }, |
| 1228 | |
| 1229 | pushStringParam: function(string) { |
| 1230 | this.pushStack('depth' + this.lastContext); |
| 1231 | this.pushString(string); |
| 1232 | }, |
| 1233 | |
| 1234 | pushString: function(string) { |
| 1235 | this.pushStack(this.quotedString(string)); |
| 1236 | }, |
| 1237 | |
| 1238 | push: function(name) { |
| 1239 | this.pushStack(name); |
| 1240 | }, |
| 1241 | |
| 1242 | invokeMustache: function(paramSize, original, hasHash) { |
| 1243 | this.populateParams(paramSize, this.quotedString(original), "{}", null, hasHash, function(nextStack, helperMissingString, id) { |
| 1244 | if (!this.usingKnownHelper) { |
| 1245 | this.context.aliases.helperMissing = 'helpers.helperMissing'; |
| 1246 | this.context.aliases.undef = 'void 0'; |
| 1247 | this.source.push("else if(" + id + "=== undef) { " + nextStack + " = helperMissing.call(" + helperMissingString + "); }"); |
| 1248 | if (nextStack !== id) { |
| 1249 | this.source.push("else { " + nextStack + " = " + id + "; }"); |
| 1250 | } |
| 1251 | } |
| 1252 | }); |
| 1253 | }, |
| 1254 | |
| 1255 | invokeProgram: function(guid, paramSize, hasHash) { |
| 1256 | var inverse = this.programExpression(this.inverse); |
| 1257 | var mainProgram = this.programExpression(guid); |
| 1258 | |
| 1259 | this.populateParams(paramSize, null, mainProgram, inverse, hasHash, function(nextStack, helperMissingString, id) { |
| 1260 | if (!this.usingKnownHelper) { |
| 1261 | this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing'; |
| 1262 | this.source.push("else { " + nextStack + " = blockHelperMissing.call(" + helperMissingString + "); }"); |
| 1263 | } |
| 1264 | }); |
| 1265 | }, |
| 1266 | |
| 1267 | populateParams: function(paramSize, helperId, program, inverse, hasHash, fn) { |
| 1268 | var needsRegister = hasHash || this.options.stringParams || inverse || this.options.data; |
| 1269 | var id = this.popStack(), nextStack; |
| 1270 | var params = [], param, stringParam, stringOptions; |
| 1271 | |
| 1272 | if (needsRegister) { |
| 1273 | this.register('tmp1', program); |
| 1274 | stringOptions = 'tmp1'; |
| 1275 | } else { |
| 1276 | stringOptions = '{ hash: {} }'; |
| 1277 | } |
| 1278 | |
| 1279 | if (needsRegister) { |
| 1280 | var hash = (hasHash ? this.popStack() : '{}'); |
| 1281 | this.source.push('tmp1.hash = ' + hash + ';'); |
| 1282 | } |
| 1283 | |
| 1284 | if(this.options.stringParams) { |
| 1285 | this.source.push('tmp1.contexts = [];'); |
| 1286 | } |
| 1287 | |
| 1288 | for(var i=0; i<paramSize; i++) { |
| 1289 | param = this.popStack(); |
| 1290 | params.push(param); |
| 1291 | |
| 1292 | if(this.options.stringParams) { |
| 1293 | this.source.push('tmp1.contexts.push(' + this.popStack() + ');'); |
| 1294 | } |
| 1295 | } |
| 1296 | |
| 1297 | if(inverse) { |
| 1298 | this.source.push('tmp1.fn = tmp1;'); |
| 1299 | this.source.push('tmp1.inverse = ' + inverse + ';'); |
| 1300 | } |
| 1301 | |
| 1302 | if(this.options.data) { |
| 1303 | this.source.push('tmp1.data = data;'); |
| 1304 | } |
| 1305 | |
| 1306 | params.push(stringOptions); |
| 1307 | |
| 1308 | this.populateCall(params, id, helperId || id, fn, program !== '{}'); |
| 1309 | }, |
| 1310 | |
| 1311 | populateCall: function(params, id, helperId, fn, program) { |
| 1312 | var paramString = ["depth0"].concat(params).join(", "); |
| 1313 | var helperMissingString = ["depth0"].concat(helperId).concat(params).join(", "); |
| 1314 | |
| 1315 | var nextStack = this.nextStack(); |
| 1316 | |
| 1317 | if (this.usingKnownHelper) { |
| 1318 | this.source.push(nextStack + " = " + id + ".call(" + paramString + ");"); |
| 1319 | } else { |
| 1320 | this.context.aliases.functionType = '"function"'; |
| 1321 | var condition = program ? "foundHelper && " : ""; |
| 1322 | this.source.push("if(" + condition + "typeof " + id + " === functionType) { " + nextStack + " = " + id + ".call(" + paramString + "); }"); |
| 1323 | } |
| 1324 | fn.call(this, nextStack, helperMissingString, id); |
| 1325 | this.usingKnownHelper = false; |
| 1326 | }, |
| 1327 | |
| 1328 | invokePartial: function(context) { |
| 1329 | params = [this.nameLookup('partials', context, 'partial'), "'" + context + "'", this.popStack(), "helpers", "partials"]; |
| 1330 | |
| 1331 | if (this.options.data) { |
| 1332 | params.push("data"); |
| 1333 | } |
| 1334 | |
| 1335 | this.pushStack("self.invokePartial(" + params.join(", ") + ");"); |
| 1336 | }, |
| 1337 | |
| 1338 | assignToHash: function(key) { |
| 1339 | var value = this.popStack(); |
| 1340 | var hash = this.topStack(); |
| 1341 | |
| 1342 | this.source.push(hash + "['" + key + "'] = " + value + ";"); |
| 1343 | }, |
| 1344 | |
| 1345 | // HELPERS |
| 1346 | |
| 1347 | compiler: JavaScriptCompiler, |
| 1348 | |
| 1349 | compileChildren: function(environment, options) { |
| 1350 | var children = environment.children, child, compiler; |
| 1351 | |
| 1352 | for(var i=0, l=children.length; i<l; i++) { |
| 1353 | child = children[i]; |
| 1354 | compiler = new this.compiler(); |
| 1355 | |
| 1356 | this.context.programs.push(''); // Placeholder to prevent name conflicts for nested children |
| 1357 | var index = this.context.programs.length; |
| 1358 | child.index = index; |
| 1359 | child.name = 'program' + index; |
| 1360 | this.context.programs[index] = compiler.compile(child, options, this.context); |
| 1361 | } |
| 1362 | }, |
| 1363 | |
| 1364 | programExpression: function(guid) { |
| 1365 | if(guid == null) { return "self.noop"; } |
| 1366 | |
| 1367 | var child = this.environment.children[guid], |
| 1368 | depths = child.depths.list; |
| 1369 | var programParams = [child.index, child.name, "data"]; |
| 1370 | |
| 1371 | for(var i=0, l = depths.length; i<l; i++) { |
| 1372 | depth = depths[i]; |
| 1373 | |
| 1374 | if(depth === 1) { programParams.push("depth0"); } |
| 1375 | else { programParams.push("depth" + (depth - 1)); } |
| 1376 | } |
| 1377 | |
| 1378 | if(depths.length === 0) { |
| 1379 | return "self.program(" + programParams.join(", ") + ")"; |
| 1380 | } else { |
| 1381 | programParams.shift(); |
| 1382 | return "self.programWithDepth(" + programParams.join(", ") + ")"; |
| 1383 | } |
| 1384 | }, |
| 1385 | |
| 1386 | register: function(name, val) { |
| 1387 | this.useRegister(name); |
| 1388 | this.source.push(name + " = " + val + ";"); |
| 1389 | }, |
| 1390 | |
| 1391 | useRegister: function(name) { |
| 1392 | if(!this.context.registers[name]) { |
| 1393 | this.context.registers[name] = true; |
| 1394 | this.context.registers.list.push(name); |
| 1395 | } |
| 1396 | }, |
| 1397 | |
| 1398 | pushStack: function(item) { |
| 1399 | this.source.push(this.nextStack() + " = " + item + ";"); |
| 1400 | return "stack" + this.stackSlot; |
| 1401 | }, |
| 1402 | |
| 1403 | nextStack: function() { |
| 1404 | this.stackSlot++; |
| 1405 | if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); } |
| 1406 | return "stack" + this.stackSlot; |
| 1407 | }, |
| 1408 | |
| 1409 | popStack: function() { |
| 1410 | return "stack" + this.stackSlot--; |
| 1411 | }, |
| 1412 | |
| 1413 | topStack: function() { |
| 1414 | return "stack" + this.stackSlot; |
| 1415 | }, |
| 1416 | |
| 1417 | quotedString: function(str) { |
| 1418 | return '"' + str |
| 1419 | .replace(/\\/g, '\\\\') |
| 1420 | .replace(/"/g, '\\"') |
| 1421 | .replace(/\n/g, '\\n') |
| 1422 | .replace(/\r/g, '\\r') + '"'; |
| 1423 | } |
| 1424 | }; |
| 1425 | |
| 1426 | var reservedWords = ( |
| 1427 | "break else new var" + |
| 1428 | " case finally return void" + |
| 1429 | " catch for switch while" + |
| 1430 | " continue function this with" + |
| 1431 | " default if throw" + |
| 1432 | " delete in try" + |
| 1433 | " do instanceof typeof" + |
| 1434 | " abstract enum int short" + |
| 1435 | " boolean export interface static" + |
| 1436 | " byte extends long super" + |
| 1437 | " char final native synchronized" + |
| 1438 | " class float package throws" + |
| 1439 | " const goto private transient" + |
| 1440 | " debugger implements protected volatile" + |
| 1441 | " double import public let yield" |
| 1442 | ).split(" "); |
| 1443 | |
| 1444 | var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {}; |
| 1445 | |
| 1446 | for(var i=0, l=reservedWords.length; i<l; i++) { |
| 1447 | compilerWords[reservedWords[i]] = true; |
| 1448 | } |
| 1449 | |
| 1450 | JavaScriptCompiler.isValidJavaScriptVariableName = function(name) { |
| 1451 | if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) { |
| 1452 | return true; |
| 1453 | } |
| 1454 | return false; |
| 1455 | } |
| 1456 | |
| 1457 | })(Handlebars.Compiler, Handlebars.JavaScriptCompiler); |
| 1458 | |
| 1459 | Handlebars.precompile = function(string, options) { |
| 1460 | options = options || {}; |
| 1461 | |
| 1462 | var ast = Handlebars.parse(string); |
| 1463 | var environment = new Handlebars.Compiler().compile(ast, options); |
| 1464 | return new Handlebars.JavaScriptCompiler().compile(environment, options); |
| 1465 | }; |
| 1466 | |
| 1467 | Handlebars.compile = function(string, options) { |
| 1468 | options = options || {}; |
| 1469 | |
| 1470 | var compiled; |
| 1471 | function compile() { |
| 1472 | var ast = Handlebars.parse(string); |
| 1473 | var environment = new Handlebars.Compiler().compile(ast, options); |
| 1474 | var templateSpec = new Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true); |
| 1475 | return Handlebars.template(templateSpec); |
| 1476 | } |
| 1477 | |
| 1478 | // Template is only compiled on first use and cached after that point. |
| 1479 | return function(context, options) { |
| 1480 | if (!compiled) { |
| 1481 | compiled = compile(); |
| 1482 | } |
| 1483 | return compiled.call(this, context, options); |
| 1484 | }; |
| 1485 | }; |
| 1486 | ; |
| 1487 | // lib/handlebars/runtime.js |
| 1488 | Handlebars.VM = { |
| 1489 | template: function(templateSpec) { |
| 1490 | // Just add water |
| 1491 | var container = { |
| 1492 | escapeExpression: Handlebars.Utils.escapeExpression, |
| 1493 | invokePartial: Handlebars.VM.invokePartial, |
| 1494 | programs: [], |
| 1495 | program: function(i, fn, data) { |
| 1496 | var programWrapper = this.programs[i]; |
| 1497 | if(data) { |
| 1498 | return Handlebars.VM.program(fn, data); |
| 1499 | } else if(programWrapper) { |
| 1500 | return programWrapper; |
| 1501 | } else { |
| 1502 | programWrapper = this.programs[i] = Handlebars.VM.program(fn); |
| 1503 | return programWrapper; |
| 1504 | } |
| 1505 | }, |
| 1506 | programWithDepth: Handlebars.VM.programWithDepth, |
| 1507 | noop: Handlebars.VM.noop |
| 1508 | }; |
| 1509 | |
| 1510 | return function(context, options) { |
| 1511 | options = options || {}; |
| 1512 | return templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data); |
| 1513 | }; |
| 1514 | }, |
| 1515 | |
| 1516 | programWithDepth: function(fn, data, $depth) { |
| 1517 | var args = Array.prototype.slice.call(arguments, 2); |
| 1518 | |
| 1519 | return function(context, options) { |
| 1520 | options = options || {}; |
| 1521 | |
| 1522 | return fn.apply(this, [context, options.data || data].concat(args)); |
| 1523 | }; |
| 1524 | }, |
| 1525 | program: function(fn, data) { |
| 1526 | return function(context, options) { |
| 1527 | options = options || {}; |
| 1528 | |
| 1529 | return fn(context, options.data || data); |
| 1530 | }; |
| 1531 | }, |
| 1532 | noop: function() { return ""; }, |
| 1533 | invokePartial: function(partial, name, context, helpers, partials, data) { |
| 1534 | options = { helpers: helpers, partials: partials, data: data }; |
| 1535 | |
| 1536 | if(partial === undefined) { |
| 1537 | throw new Handlebars.Exception("The partial " + name + " could not be found"); |
| 1538 | } else if(partial instanceof Function) { |
| 1539 | return partial(context, options); |
| 1540 | } else if (!Handlebars.compile) { |
| 1541 | throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode"); |
| 1542 | } else { |
| 1543 | partials[name] = Handlebars.compile(partial); |
| 1544 | return partials[name](context, options); |
| 1545 | } |
| 1546 | } |
| 1547 | }; |
| 1548 | |
| 1549 | Handlebars.template = Handlebars.VM.template; |
| 1550 | ; |
| 1551 |