vendor: 89,667 bytes, lines 1-2746
1/*! 2 3 handlebars v1.3.0 4 5Copyright (C) 2011 by Yehuda Katz 6 7Permission is hereby granted, free of charge, to any person obtaining a copy 8of this software and associated documentation files (the "Software"), to deal 9in the Software without restriction, including without limitation the rights 10to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11copies of the Software, and to permit persons to whom the Software is 12furnished to do so, subject to the following conditions: 13 14The above copyright notice and this permission notice shall be included in 15all copies or substantial portions of the Software. 16 17THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23THE SOFTWARE. 24 25@license 26*/ 27/* exported Handlebars */ 28var Handlebars = (function() { 29// handlebars/safe-string.js 30var __module4__ = (function() { 31 "use strict"; 32 var __exports__; 33 // Build out our basic SafeString type 34 function SafeString(string) { 35 this.string = string; 36 } 37 38 SafeString.prototype.toString = function() { 39 return "" + this.string; 40 }; 41 42 __exports__ = SafeString; 43 return __exports__; 44})(); 45 46// handlebars/utils.js 47var __module3__ = (function(__dependency1__) { 48 "use strict"; 49 var __exports__ = {}; 50 /*jshint -W004 */ 51 var SafeString = __dependency1__; 52 53 var escape = { 54 "&": "&", 55 "<": "<", 56 ">": ">", 57 '"': """, 58 "'": "'", 59 "`": "`" 60 }; 61 62 var badChars = /[&<>"'`]/g; 63 var possible = /[&<>"'`]/; 64 65 function escapeChar(chr) { 66 return escape[chr] || "&"; 67 } 68 69 function extend(obj, value) { 70 for(var key in value) { 71 if(Object.prototype.hasOwnProperty.call(value, key)) { 72 obj[key] = value[key]; 73 } 74 } 75 } 76 77 __exports__.extend = extend;var toString = Object.prototype.toString; 78 __exports__.toString = toString; 79 // Sourced from lodash 80 // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt 81 var isFunction = function(value) { 82 return typeof value === 'function'; 83 }; 84 // fallback for older versions of Chrome and Safari 85 if (isFunction(/x/)) { 86 isFunction = function(value) { 87 return typeof value === 'function' && toString.call(value) === '[object Function]'; 88 }; 89 } 90 var isFunction; 91 __exports__.isFunction = isFunction; 92 var isArray = Array.isArray || function(value) { 93 return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false; 94 }; 95 __exports__.isArray = isArray; 96 97 function escapeExpression(string) { 98 // don't escape SafeStrings, since they're already safe 99 if (string instanceof SafeString) { 100 return string.toString(); 101 } else if (!string && string !== 0) { 102 return ""; 103 } 104 105 // Force a string conversion as this will be done by the append regardless and 106 // the regex test will do this transparently behind the scenes, causing issues if 107 // an object's to string has escaped characters in it. 108 string = "" + string; 109 110 if(!possible.test(string)) { return string; } 111 return string.replace(badChars, escapeChar); 112 } 113 114 __exports__.escapeExpression = escapeExpression;function isEmpty(value) { 115 if (!value && value !== 0) { 116 return true; 117 } else if (isArray(value) && value.length === 0) { 118 return true; 119 } else { 120 return false; 121 } 122 } 123 124 __exports__.isEmpty = isEmpty; 125 return __exports__; 126})(__module4__); 127 128// handlebars/exception.js 129var __module5__ = (function() { 130 "use strict"; 131 var __exports__; 132 133 var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack']; 134 135 function Exception(message, node) { 136 var line; 137 if (node && node.firstLine) { 138 line = node.firstLine; 139 140 message += ' - ' + line + ':' + node.firstColumn; 141 } 142 143 var tmp = Error.prototype.constructor.call(this, message); 144 145 // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work. 146 for (var idx = 0; idx < errorProps.length; idx++) { 147 this[errorProps[idx]] = tmp[errorProps[idx]]; 148 } 149 150 if (line) { 151 this.lineNumber = line; 152 this.column = node.firstColumn; 153 } 154 } 155 156 Exception.prototype = new Error(); 157 158 __exports__ = Exception; 159 return __exports__; 160})(); 161 162// handlebars/base.js 163var __module2__ = (function(__dependency1__, __dependency2__) { 164 "use strict"; 165 var __exports__ = {}; 166 var Utils = __dependency1__; 167 var Exception = __dependency2__; 168 169 var VERSION = "1.3.0"; 170 __exports__.VERSION = VERSION;var COMPILER_REVISION = 4; 171 __exports__.COMPILER_REVISION = COMPILER_REVISION; 172 var REVISION_CHANGES = { 173 1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it 174 2: '== 1.0.0-rc.3', 175 3: '== 1.0.0-rc.4', 176 4: '>= 1.0.0' 177 }; 178 __exports__.REVISION_CHANGES = REVISION_CHANGES; 179 var isArray = Utils.isArray, 180 isFunction = Utils.isFunction, 181 toString = Utils.toString, 182 objectType = '[object Object]'; 183 184 function HandlebarsEnvironment(helpers, partials) { 185 this.helpers = helpers || {}; 186 this.partials = partials || {}; 187 188 registerDefaultHelpers(this); 189 } 190 191 __exports__.HandlebarsEnvironment = HandlebarsEnvironment;HandlebarsEnvironment.prototype = { 192 constructor: HandlebarsEnvironment, 193 194 logger: logger, 195 log: log, 196 197 registerHelper: function(name, fn, inverse) { 198 if (toString.call(name) === objectType) { 199 if (inverse || fn) { throw new Exception('Arg not supported with multiple helpers'); } 200 Utils.extend(this.helpers, name); 201 } else { 202 if (inverse) { fn.not = inverse; } 203 this.helpers[name] = fn; 204 } 205 }, 206 207 registerPartial: function(name, str) { 208 if (toString.call(name) === objectType) { 209 Utils.extend(this.partials, name); 210 } else { 211 this.partials[name] = str; 212 } 213 } 214 }; 215 216 function registerDefaultHelpers(instance) { 217 instance.registerHelper('helperMissing', function(arg) { 218 if(arguments.length === 2) { 219 return undefined; 220 } else { 221 throw new Exception("Missing helper: '" + arg + "'"); 222 } 223 }); 224 225 instance.registerHelper('blockHelperMissing', function(context, options) { 226 var inverse = options.inverse || function() {}, fn = options.fn; 227 228 if (isFunction(context)) { context = context.call(this); } 229 230 if(context === true) { 231 return fn(this); 232 } else if(context === false || context == null) { 233 return inverse(this); 234 } else if (isArray(context)) { 235 if(context.length > 0) { 236 return instance.helpers.each(context, options); 237 } else { 238 return inverse(this); 239 } 240 } else { 241 return fn(context); 242 } 243 }); 244 245 instance.registerHelper('each', function(context, options) { 246 var fn = options.fn, inverse = options.inverse; 247 var i = 0, ret = "", data; 248 249 if (isFunction(context)) { context = context.call(this); } 250 251 if (options.data) { 252 data = createFrame(options.data); 253 } 254 255 if(context && typeof context === 'object') { 256 if (isArray(context)) { 257 for(var j = context.length; i<j; i++) { 258 if (data) { 259 data.index = i; 260 data.first = (i === 0); 261 data.last = (i === (context.length-1)); 262 } 263 ret = ret + fn(context[i], { data: data }); 264 } 265 } else { 266 for(var key in context) { 267 if(context.hasOwnProperty(key)) { 268 if(data) { 269 data.key = key; 270 data.index = i; 271 data.first = (i === 0); 272 } 273 ret = ret + fn(context[key], {data: data}); 274 i++; 275 } 276 } 277 } 278 } 279 280 if(i === 0){ 281 ret = inverse(this); 282 } 283 284 return ret; 285 }); 286 287 instance.registerHelper('if', function(conditional, options) { 288 if (isFunction(conditional)) { conditional = conditional.call(this); } 289 290 // Default behavior is to render the positive path if the value is truthy and not empty. 291 // The `includeZero` option may be set to treat the condtional as purely not empty based on the 292 // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative. 293 if ((!options.hash.includeZero && !conditional) || Utils.isEmpty(conditional)) { 294 return options.inverse(this); 295 } else { 296 return options.fn(this); 297 } 298 }); 299 300 instance.registerHelper('unless', function(conditional, options) { 301 return instance.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn, hash: options.hash}); 302 }); 303 304 instance.registerHelper('with', function(context, options) { 305 if (isFunction(context)) { context = context.call(this); } 306 307 if (!Utils.isEmpty(context)) return options.fn(context); 308 }); 309 310 instance.registerHelper('log', function(context, options) { 311 var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1; 312 instance.log(level, context); 313 }); 314 } 315 316 var logger = { 317 methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' }, 318 319 // State enum 320 DEBUG: 0, 321 INFO: 1, 322 WARN: 2, 323 ERROR: 3, 324 level: 3, 325 326 // can be overridden in the host environment 327 log: function(level, obj) { 328 if (logger.level <= level) { 329 var method = logger.methodMap[level]; 330 if (typeof console !== 'undefined' && console[method]) { 331 console[method].call(console, obj); 332 } 333 } 334 } 335 }; 336 __exports__.logger = logger; 337 function log(level, obj) { logger.log(level, obj); } 338 339 __exports__.log = log;var createFrame = function(object) { 340 var obj = {}; 341 Utils.extend(obj, object); 342 return obj; 343 }; 344 __exports__.createFrame = createFrame; 345 return __exports__; 346})(__module3__, __module5__); 347 348// handlebars/runtime.js 349var __module6__ = (function(__dependency1__, __dependency2__, __dependency3__) { 350 "use strict"; 351 var __exports__ = {}; 352 var Utils = __dependency1__; 353 var Exception = __dependency2__; 354 var COMPILER_REVISION = __dependency3__.COMPILER_REVISION; 355 var REVISION_CHANGES = __dependency3__.REVISION_CHANGES; 356 357 function checkRevision(compilerInfo) { 358 var compilerRevision = compilerInfo && compilerInfo[0] || 1, 359 currentRevision = COMPILER_REVISION; 360 361 if (compilerRevision !== currentRevision) { 362 if (compilerRevision < currentRevision) { 363 var runtimeVersions = REVISION_CHANGES[currentRevision], 364 compilerVersions = REVISION_CHANGES[compilerRevision]; 365 throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. "+ 366 "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+")."); 367 } else { 368 // Use the embedded version info since the runtime doesn't know about this revision yet 369 throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. "+ 370 "Please update your runtime to a newer version ("+compilerInfo[1]+")."); 371 } 372 } 373 } 374 375 __exports__.checkRevision = checkRevision;// TODO: Remove this line and break up compilePartial 376 377 function template(templateSpec, env) { 378 if (!env) { 379 throw new Exception("No environment passed to template"); 380 } 381 382 // Note: Using env.VM references rather than local var references throughout this section to allow 383 // for external users to override these as psuedo-supported APIs. 384 var invokePartialWrapper = function(partial, name, context, helpers, partials, data) { 385 var result = env.VM.invokePartial.apply(this, arguments); 386 if (result != null) { return result; } 387 388 if (env.compile) { 389 var options = { helpers: helpers, partials: partials, data: data }; 390 partials[name] = env.compile(partial, { data: data !== undefined }, env); 391 return partials[name](context, options); 392 } else { 393 throw new Exception("The partial " + name + " could not be compiled when running in runtime-only mode"); 394 } 395 }; 396 397 // Just add water 398 var container = { 399 escapeExpression: Utils.escapeExpression, 400 invokePartial: invokePartialWrapper, 401 programs: [], 402 program: function(i, fn, data) { 403 var programWrapper = this.programs[i]; 404 if(data) { 405 programWrapper = program(i, fn, data); 406 } else if (!programWrapper) { 407 programWrapper = this.programs[i] = program(i, fn); 408 } 409 return programWrapper; 410 }, 411 merge: function(param, common) { 412 var ret = param || common; 413 414 if (param && common && (param !== common)) { 415 ret = {}; 416 Utils.extend(ret, common); 417 Utils.extend(ret, param); 418 } 419 return ret; 420 }, 421 programWithDepth: env.VM.programWithDepth, 422 noop: env.VM.noop, 423 compilerInfo: null 424 }; 425 426 return function(context, options) { 427 options = options || {}; 428 var namespace = options.partial ? options : env, 429 helpers, 430 partials; 431 432 if (!options.partial) { 433 helpers = options.helpers; 434 partials = options.partials; 435 } 436 var result = templateSpec.call( 437 container, 438 namespace, context, 439 helpers, 440 partials, 441 options.data); 442 443 if (!options.partial) { 444 env.VM.checkRevision(container.compilerInfo); 445 } 446 447 return result; 448 }; 449 } 450 451 __exports__.template = template;function programWithDepth(i, fn, data /*, $depth */) { 452 var args = Array.prototype.slice.call(arguments, 3); 453 454 var prog = function(context, options) { 455 options = options || {}; 456 457 return fn.apply(this, [context, options.data || data].concat(args)); 458 }; 459 prog.program = i; 460 prog.depth = args.length; 461 return prog; 462 } 463 464 __exports__.programWithDepth = programWithDepth;function program(i, fn, data) { 465 var prog = function(context, options) { 466 options = options || {}; 467 468 return fn(context, options.data || data); 469 }; 470 prog.program = i; 471 prog.depth = 0; 472 return prog; 473 } 474 475 __exports__.program = program;function invokePartial(partial, name, context, helpers, partials, data) { 476 var options = { partial: true, helpers: helpers, partials: partials, data: data }; 477 478 if(partial === undefined) { 479 throw new Exception("The partial " + name + " could not be found"); 480 } else if(partial instanceof Function) { 481 return partial(context, options); 482 } 483 } 484 485 __exports__.invokePartial = invokePartial;function noop() { return ""; } 486 487 __exports__.noop = noop; 488 return __exports__; 489})(__module3__, __module5__, __module2__); 490 491// handlebars.runtime.js 492var __module1__ = (function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) { 493 "use strict"; 494 var __exports__; 495 /*globals Handlebars: true */ 496 var base = __dependency1__; 497 498 // Each of these augment the Handlebars object. No need to setup here. 499 // (This is done to easily share code between commonjs and browse envs) 500 var SafeString = __dependency2__; 501 var Exception = __dependency3__; 502 var Utils = __dependency4__; 503 var runtime = __dependency5__; 504 505 // For compatibility and usage outside of module systems, make the Handlebars object a namespace 506 var create = function() { 507 var hb = new base.HandlebarsEnvironment(); 508 509 Utils.extend(hb, base); 510 hb.SafeString = SafeString; 511 hb.Exception = Exception; 512 hb.Utils = Utils; 513 514 hb.VM = runtime; 515 hb.template = function(spec) { 516 return runtime.template(spec, hb); 517 }; 518 519 return hb; 520 }; 521 522 var Handlebars = create(); 523 Handlebars.create = create; 524 525 __exports__ = Handlebars; 526 return __exports__; 527})(__module2__, __module4__, __module5__, __module3__, __module6__); 528 529// handlebars/compiler/ast.js 530var __module7__ = (function(__dependency1__) { 531 "use strict"; 532 var __exports__; 533 var Exception = __dependency1__; 534 535 function LocationInfo(locInfo){ 536 locInfo = locInfo || {}; 537 this.firstLine = locInfo.first_line; 538 this.firstColumn = locInfo.first_column; 539 this.lastColumn = locInfo.last_column; 540 this.lastLine = locInfo.last_line; 541 } 542 543 var AST = { 544 ProgramNode: function(statements, inverseStrip, inverse, locInfo) { 545 var inverseLocationInfo, firstInverseNode; 546 if (arguments.length === 3) { 547 locInfo = inverse; 548 inverse = null; 549 } else if (arguments.length === 2) { 550 locInfo = inverseStrip; 551 inverseStrip = null; 552 } 553 554 LocationInfo.call(this, locInfo); 555 this.type = "program"; 556 this.statements = statements; 557 this.strip = {}; 558 559 if(inverse) { 560 firstInverseNode = inverse[0]; 561 if (firstInverseNode) { 562 inverseLocationInfo = { 563 first_line: firstInverseNode.firstLine, 564 last_line: firstInverseNode.lastLine, 565 last_column: firstInverseNode.lastColumn, 566 first_column: firstInverseNode.firstColumn 567 }; 568 this.inverse = new AST.ProgramNode(inverse, inverseStrip, inverseLocationInfo); 569 } else { 570 this.inverse = new AST.ProgramNode(inverse, inverseStrip); 571 } 572 this.strip.right = inverseStrip.left; 573 } else if (inverseStrip) { 574 this.strip.left = inverseStrip.right; 575 } 576 }, 577 578 MustacheNode: function(rawParams, hash, open, strip, locInfo) { 579 LocationInfo.call(this, locInfo); 580 this.type = "mustache"; 581 this.strip = strip; 582 583 // Open may be a string parsed from the parser or a passed boolean flag 584 if (open != null && open.charAt) { 585 // Must use charAt to support IE pre-10 586 var escapeFlag = open.charAt(3) || open.charAt(2); 587 this.escaped = escapeFlag !== '{' && escapeFlag !== '&'; 588 } else { 589 this.escaped = !!open; 590 } 591 592 if (rawParams instanceof AST.SexprNode) { 593 this.sexpr = rawParams; 594 } else { 595 // Support old AST API 596 this.sexpr = new AST.SexprNode(rawParams, hash); 597 } 598 599 this.sexpr.isRoot = true; 600 601 // Support old AST API that stored this info in MustacheNode 602 this.id = this.sexpr.id; 603 this.params = this.sexpr.params; 604 this.hash = this.sexpr.hash; 605 this.eligibleHelper = this.sexpr.eligibleHelper; 606 this.isHelper = this.sexpr.isHelper; 607 }, 608 609 SexprNode: function(rawParams, hash, locInfo) { 610 LocationInfo.call(this, locInfo); 611 612 this.type = "sexpr"; 613 this.hash = hash; 614 615 var id = this.id = rawParams[0]; 616 var params = this.params = rawParams.slice(1); 617 618 // a mustache is an eligible helper if: 619 // * its id is simple (a single part, not `this` or `..`) 620 var eligibleHelper = this.eligibleHelper = id.isSimple; 621 622 // a mustache is definitely a helper if: 623 // * it is an eligible helper, and 624 // * it has at least one parameter or hash segment 625 this.isHelper = eligibleHelper && (params.length || hash); 626 627 // if a mustache is an eligible helper but not a definite 628 // helper, it is ambiguous, and will be resolved in a later 629 // pass or at runtime. 630 }, 631 632 PartialNode: function(partialName, context, strip, locInfo) { 633 LocationInfo.call(this, locInfo); 634 this.type = "partial"; 635 this.partialName = partialName; 636 this.context = context; 637 this.strip = strip; 638 }, 639 640 BlockNode: function(mustache, program, inverse, close, locInfo) { 641 LocationInfo.call(this, locInfo); 642 643 if(mustache.sexpr.id.original !== close.path.original) { 644 throw new Exception(mustache.sexpr.id.original + " doesn't match " + close.path.original, this); 645 } 646 647 this.type = 'block'; 648 this.mustache = mustache; 649 this.program = program; 650 this.inverse = inverse; 651 652 this.strip = { 653 left: mustache.strip.left, 654 right: close.strip.right 655 }; 656 657 (program || inverse).strip.left = mustache.strip.right; 658 (inverse || program).strip.right = close.strip.left; 659 660 if (inverse && !program) { 661 this.isInverse = true; 662 } 663 }, 664 665 ContentNode: function(string, locInfo) { 666 LocationInfo.call(this, locInfo); 667 this.type = "content"; 668 this.string = string; 669 }, 670 671 HashNode: function(pairs, locInfo) { 672 LocationInfo.call(this, locInfo); 673 this.type = "hash"; 674 this.pairs = pairs; 675 }, 676 677 IdNode: function(parts, locInfo) { 678 LocationInfo.call(this, locInfo); 679 this.type = "ID"; 680 681 var original = "", 682 dig = [], 683 depth = 0; 684 685 for(var i=0,l=parts.length; i<l; i++) { 686 var part = parts[i].part; 687 original += (parts[i].separator || '') + part; 688 689 if (part === ".." || part === "." || part === "this") { 690 if (dig.length > 0) { 691 throw new Exception("Invalid path: " + original, this); 692 } else if (part === "..") { 693 depth++; 694 } else { 695 this.isScoped = true; 696 } 697 } else { 698 dig.push(part); 699 } 700 } 701 702 this.original = original; 703 this.parts = dig; 704 this.string = dig.join('.'); 705 this.depth = depth; 706 707 // an ID is simple if it only has one part, and that part is not 708 // `..` or `this`. 709 this.isSimple = parts.length === 1 && !this.isScoped && depth === 0; 710 711 this.stringModeValue = this.string; 712 }, 713 714 PartialNameNode: function(name, locInfo) { 715 LocationInfo.call(this, locInfo); 716 this.type = "PARTIAL_NAME"; 717 this.name = name.original; 718 }, 719 720 DataNode: function(id, locInfo) { 721 LocationInfo.call(this, locInfo); 722 this.type = "DATA"; 723 this.id = id; 724 }, 725 726 StringNode: function(string, locInfo) { 727 LocationInfo.call(this, locInfo); 728 this.type = "STRING"; 729 this.original = 730 this.string = 731 this.stringModeValue = string; 732 }, 733 734 IntegerNode: function(integer, locInfo) { 735 LocationInfo.call(this, locInfo); 736 this.type = "INTEGER"; 737 this.original = 738 this.integer = integer; 739 this.stringModeValue = Number(integer); 740 }, 741 742 BooleanNode: function(bool, locInfo) { 743 LocationInfo.call(this, locInfo); 744 this.type = "BOOLEAN"; 745 this.bool = bool; 746 this.stringModeValue = bool === "true"; 747 }, 748 749 CommentNode: function(comment, locInfo) { 750 LocationInfo.call(this, locInfo); 751 this.type = "comment"; 752 this.comment = comment; 753 } 754 }; 755 756 // Must be exported as an object rather than the root of the module as the jison lexer 757 // most modify the object to operate properly. 758 __exports__ = AST; 759 return __exports__; 760})(__module5__); 761 762// handlebars/compiler/parser.js 763var __module9__ = (function() { 764 "use strict"; 765 var __exports__; 766 /* jshint ignore:start */ 767 /* Jison generated parser */ 768 var handlebars = (function(){ 769 var parser = {trace: function trace() { }, 770 yy: {}, 771 symbols_: {"error":2,"root":3,"statements":4,"EOF":5,"program":6,"simpleInverse":7,"statement":8,"openInverse":9,"closeBlock":10,"openBlock":11,"mustache":12,"partial":13,"CONTENT":14,"COMMENT":15,"OPEN_BLOCK":16,"sexpr":17,"CLOSE":18,"OPEN_INVERSE":19,"OPEN_ENDBLOCK":20,"path":21,"OPEN":22,"OPEN_UNESCAPED":23,"CLOSE_UNESCAPED":24,"OPEN_PARTIAL":25,"partialName":26,"partial_option0":27,"sexpr_repetition0":28,"sexpr_option0":29,"dataName":30,"param":31,"STRING":32,"INTEGER":33,"BOOLEAN":34,"OPEN_SEXPR":35,"CLOSE_SEXPR":36,"hash":37,"hash_repetition_plus0":38,"hashSegment":39,"ID":40,"EQUALS":41,"DATA":42,"pathSegments":43,"SEP":44,"$accept":0,"$end":1}, 772 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:"CLOSE_UNESCAPED",25:"OPEN_PARTIAL",32:"STRING",33:"INTEGER",34:"BOOLEAN",35:"OPEN_SEXPR",36:"CLOSE_SEXPR",40:"ID",41:"EQUALS",42:"DATA",44:"SEP"}, 773 productions_: [0,[3,2],[3,1],[6,2],[6,3],[6,2],[6,1],[6,1],[6,0],[4,1],[4,2],[8,3],[8,3],[8,1],[8,1],[8,1],[8,1],[11,3],[9,3],[10,3],[12,3],[12,3],[13,4],[7,2],[17,3],[17,1],[31,1],[31,1],[31,1],[31,1],[31,1],[31,3],[37,1],[39,3],[26,1],[26,1],[26,1],[30,2],[21,1],[43,3],[43,1],[27,0],[27,1],[28,0],[28,2],[29,0],[29,1],[38,1],[38,2]], 774 performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) { 775 776 var $0 = $$.length - 1; 777 switch (yystate) { 778 case 1: return new yy.ProgramNode($$[$0-1], this._$); 779 break; 780 case 2: return new yy.ProgramNode([], this._$); 781 break; 782 case 3:this.$ = new yy.ProgramNode([], $$[$0-1], $$[$0], this._$); 783 break; 784 case 4:this.$ = new yy.ProgramNode($$[$0-2], $$[$0-1], $$[$0], this._$); 785 break; 786 case 5:this.$ = new yy.ProgramNode($$[$0-1], $$[$0], [], this._$); 787 break; 788 case 6:this.$ = new yy.ProgramNode($$[$0], this._$); 789 break; 790 case 7:this.$ = new yy.ProgramNode([], this._$); 791 break; 792 case 8:this.$ = new yy.ProgramNode([], this._$); 793 break; 794 case 9:this.$ = [$$[$0]]; 795 break; 796 case 10: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; 797 break; 798 case 11:this.$ = new yy.BlockNode($$[$0-2], $$[$0-1].inverse, $$[$0-1], $$[$0], this._$); 799 break; 800 case 12:this.$ = new yy.BlockNode($$[$0-2], $$[$0-1], $$[$0-1].inverse, $$[$0], this._$); 801 break; 802 case 13:this.$ = $$[$0]; 803 break; 804 case 14:this.$ = $$[$0]; 805 break; 806 case 15:this.$ = new yy.ContentNode($$[$0], this._$); 807 break; 808 case 16:this.$ = new yy.CommentNode($$[$0], this._$); 809 break; 810 case 17:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], stripFlags($$[$0-2], $$[$0]), this._$); 811 break; 812 case 18:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], stripFlags($$[$0-2], $$[$0]), this._$); 813 break; 814 case 19:this.$ = {path: $$[$0-1], strip: stripFlags($$[$0-2], $$[$0])}; 815 break; 816 case 20:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], stripFlags($$[$0-2], $$[$0]), this._$); 817 break; 818 case 21:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], stripFlags($$[$0-2], $$[$0]), this._$); 819 break; 820 case 22:this.$ = new yy.PartialNode($$[$0-2], $$[$0-1], stripFlags($$[$0-3], $$[$0]), this._$); 821 break; 822 case 23:this.$ = stripFlags($$[$0-1], $$[$0]); 823 break; 824 case 24:this.$ = new yy.SexprNode([$$[$0-2]].concat($$[$0-1]), $$[$0], this._$); 825 break; 826 case 25:this.$ = new yy.SexprNode([$$[$0]], null, this._$); 827 break; 828 case 26:this.$ = $$[$0]; 829 break; 830 case 27:this.$ = new yy.StringNode($$[$0], this._$); 831 break; 832 case 28:this.$ = new yy.IntegerNode($$[$0], this._$); 833 break; 834 case 29:this.$ = new yy.BooleanNode($$[$0], this._$); 835 break; 836 case 30:this.$ = $$[$0]; 837 break; 838 case 31:$$[$0-1].isHelper = true; this.$ = $$[$0-1]; 839 break; 840 case 32:this.$ = new yy.HashNode($$[$0], this._$); 841 break; 842 case 33:this.$ = [$$[$0-2], $$[$0]]; 843 break; 844 case 34:this.$ = new yy.PartialNameNode($$[$0], this._$); 845 break; 846 case 35:this.$ = new yy.PartialNameNode(new yy.StringNode($$[$0], this._$), this._$); 847 break; 848 case 36:this.$ = new yy.PartialNameNode(new yy.IntegerNode($$[$0], this._$)); 849 break; 850 case 37:this.$ = new yy.DataNode($$[$0], this._$); 851 break; 852 case 38:this.$ = new yy.IdNode($$[$0], this._$); 853 break; 854 case 39: $$[$0-2].push({part: $$[$0], separator: $$[$0-1]}); this.$ = $$[$0-2]; 855 break; 856 case 40:this.$ = [{part: $$[$0]}]; 857 break; 858 case 43:this.$ = []; 859 break; 860 case 44:$$[$0-1].push($$[$0]); 861 break; 862 case 47:this.$ = [$$[$0]]; 863 break; 864 case 48:$$[$0-1].push($$[$0]); 865 break; 866 } 867 }, 868 table: [{3:1,4:2,5:[1,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],25:[1,15]},{1:[3]},{5:[1,16],8:17,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],25:[1,15]},{1:[2,2]},{5:[2,9],14:[2,9],15:[2,9],16:[2,9],19:[2,9],20:[2,9],22:[2,9],23:[2,9],25:[2,9]},{4:20,6:18,7:19,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,21],20:[2,8],22:[1,13],23:[1,14],25:[1,15]},{4:20,6:22,7:19,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,21],20:[2,8],22:[1,13],23:[1,14],25:[1,15]},{5:[2,13],14:[2,13],15:[2,13],16:[2,13],19:[2,13],20:[2,13],22:[2,13],23:[2,13],25:[2,13]},{5:[2,14],14:[2,14],15:[2,14],16:[2,14],19:[2,14],20:[2,14],22:[2,14],23:[2,14],25:[2,14]},{5:[2,15],14:[2,15],15:[2,15],16:[2,15],19:[2,15],20:[2,15],22:[2,15],23:[2,15],25:[2,15]},{5:[2,16],14:[2,16],15:[2,16],16:[2,16],19:[2,16],20:[2,16],22:[2,16],23:[2,16],25:[2,16]},{17:23,21:24,30:25,40:[1,28],42:[1,27],43:26},{17:29,21:24,30:25,40:[1,28],42:[1,27],43:26},{17:30,21:24,30:25,40:[1,28],42:[1,27],43:26},{17:31,21:24,30:25,40:[1,28],42:[1,27],43:26},{21:33,26:32,32:[1,34],33:[1,35],40:[1,28],43:26},{1:[2,1]},{5:[2,10],14:[2,10],15:[2,10],16:[2,10],19:[2,10],20:[2,10],22:[2,10],23:[2,10],25:[2,10]},{10:36,20:[1,37]},{4:38,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,7],22:[1,13],23:[1,14],25:[1,15]},{7:39,8:17,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,21],20:[2,6],22:[1,13],23:[1,14],25:[1,15]},{17:23,18:[1,40],21:24,30:25,40:[1,28],42:[1,27],43:26},{10:41,20:[1,37]},{18:[1,42]},{18:[2,43],24:[2,43],28:43,32:[2,43],33:[2,43],34:[2,43],35:[2,43],36:[2,43],40:[2,43],42:[2,43]},{18:[2,25],24:[2,25],36:[2,25]},{18:[2,38],24:[2,38],32:[2,38],33:[2,38],34:[2,38],35:[2,38],36:[2,38],40:[2,38],42:[2,38],44:[1,44]},{21:45,40:[1,28],43:26},{18:[2,40],24:[2,40],32:[2,40],33:[2,40],34:[2,40],35:[2,40],36:[2,40],40:[2,40],42:[2,40],44:[2,40]},{18:[1,46]},{18:[1,47]},{24:[1,48]},{18:[2,41],21:50,27:49,40:[1,28],43:26},{18:[2,34],40:[2,34]},{18:[2,35],40:[2,35]},{18:[2,36],40:[2,36]},{5:[2,11],14:[2,11],15:[2,11],16:[2,11],19:[2,11],20:[2,11],22:[2,11],23:[2,11],25:[2,11]},{21:51,40:[1,28],43:26},{8:17,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,3],22:[1,13],23:[1,14],25:[1,15]},{4:52,8:4,9:5,11:6,12:7,13:8,14:[1,9],15:[1,10],16:[1,12],19:[1,11],20:[2,5],22:[1,13],23:[1,14],25:[1,15]},{14:[2,23],15:[2,23],16:[2,23],19:[2,23],20:[2,23],22:[2,23],23:[2,23],25:[2,23]},{5:[2,12],14:[2,12],15:[2,12],16:[2,12],19:[2,12],20:[2,12],22:[2,12],23:[2,12],25:[2,12]},{14:[2,18],15:[2,18],16:[2,18],19:[2,18],20:[2,18],22:[2,18],23:[2,18],25:[2,18]},{18:[2,45],21:56,24:[2,45],29:53,30:60,31:54,32:[1,57],33:[1,58],34:[1,59],35:[1,61],36:[2,45],37:55,38:62,39:63,40:[1,64],42:[1,27],43:26},{40:[1,65]},{18:[2,37],24:[2,37],32:[2,37],33:[2,37],34:[2,37],35:[2,37],36:[2,37],40:[2,37],42:[2,37]},{14:[2,17],15:[2,17],16:[2,17],19:[2,17],20:[2,17],22:[2,17],23:[2,17],25:[2,17]},{5:[2,20],14:[2,20],15:[2,20],16:[2,20],19:[2,20],20:[2,20],22:[2,20],23:[2,20],25:[2,20]},{5:[2,21],14:[2,21],15:[2,21],16:[2,21],19:[2,21],20:[2,21],22:[2,21],23:[2,21],25:[2,21]},{18:[1,66]},{18:[2,42]},{18:[1,67]},{8:17,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],25:[1,15]},{18:[2,24],24:[2,24],36:[2,24]},{18:[2,44],24:[2,44],32:[2,44],33:[2,44],34:[2,44],35:[2,44],36:[2,44],40:[2,44],42:[2,44]},{18:[2,46],24:[2,46],36:[2,46]},{18:[2,26],24:[2,26],32:[2,26],33:[2,26],34:[2,26],35:[2,26],36:[2,26],40:[2,26],42:[2,26]},{18:[2,27],24:[2,27],32:[2,27],33:[2,27],34:[2,27],35:[2,27],36:[2,27],40:[2,27],42:[2,27]},{18:[2,28],24:[2,28],32:[2,28],33:[2,28],34:[2,28],35:[2,28],36:[2,28],40:[2,28],42:[2,28]},{18:[2,29],24:[2,29],32:[2,29],33:[2,29],34:[2,29],35:[2,29],36:[2,29],40:[2,29],42:[2,29]},{18:[2,30],24:[2,30],32:[2,30],33:[2,30],34:[2,30],35:[2,30],36:[2,30],40:[2,30],42:[2,30]},{17:68,21:24,30:25,40:[1,28],42:[1,27],43:26},{18:[2,32],24:[2,32],36:[2,32],39:69,40:[1,70]},{18:[2,47],24:[2,47],36:[2,47],40:[2,47]},{18:[2,40],24:[2,40],32:[2,40],33:[2,40],34:[2,40],35:[2,40],36:[2,40],40:[2,40],41:[1,71],42:[2,40],44:[2,40]},{18:[2,39],24:[2,39],32:[2,39],33:[2,39],34:[2,39],35:[2,39],36:[2,39],40:[2,39],42:[2,39],44:[2,39]},{5:[2,22],14:[2,22],15:[2,22],16:[2,22],19:[2,22],20:[2,22],22:[2,22],23:[2,22],25:[2,22]},{5:[2,19],14:[2,19],15:[2,19],16:[2,19],19:[2,19],20:[2,19],22:[2,19],23:[2,19],25:[2,19]},{36:[1,72]},{18:[2,48],24:[2,48],36:[2,48],40:[2,48]},{41:[1,71]},{21:56,30:60,31:73,32:[1,57],33:[1,58],34:[1,59],35:[1,61],40:[1,28],42:[1,27],43:26},{18:[2,31],24:[2,31],32:[2,31],33:[2,31],34:[2,31],35:[2,31],36:[2,31],40:[2,31],42:[2,31]},{18:[2,33],24:[2,33],36:[2,33],40:[2,33]}], 869 defaultActions: {3:[2,2],16:[2,1],50:[2,42]}, 870 parseError: function parseError(str, hash) { 871 throw new Error(str); 872 }, 873 parse: function parse(input) { 874 var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1; 875 this.lexer.setInput(input); 876 this.lexer.yy = this.yy; 877 this.yy.lexer = this.lexer; 878 this.yy.parser = this; 879 if (typeof this.lexer.yylloc == "undefined") 880 this.lexer.yylloc = {}; 881 var yyloc = this.lexer.yylloc; 882 lstack.push(yyloc); 883 var ranges = this.lexer.options && this.lexer.options.ranges; 884 if (typeof this.yy.parseError === "function") 885 this.parseError = this.yy.parseError; 886 function popStack(n) { 887 stack.length = stack.length - 2 * n; 888 vstack.length = vstack.length - n; 889 lstack.length = lstack.length - n; 890 } 891 function lex() { 892 var token; 893 token = self.lexer.lex() || 1; 894 if (typeof token !== "number") { 895 token = self.symbols_[token] || token; 896 } 897 return token; 898 } 899 var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected; 900 while (true) { 901 state = stack[stack.length - 1]; 902 if (this.defaultActions[state]) { 903 action = this.defaultActions[state]; 904 } else { 905 if (symbol === null || typeof symbol == "undefined") { 906 symbol = lex(); 907 } 908 action = table[state] && table[state][symbol]; 909 } 910 if (typeof action === "undefined" || !action.length || !action[0]) { 911 var errStr = ""; 912 if (!recovering) { 913 expected = []; 914 for (p in table[state]) 915 if (this.terminals_[p] && p > 2) { 916 expected.push("'" + this.terminals_[p] + "'"); 917 } 918 if (this.lexer.showPosition) { 919 errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'"; 920 } else { 921 errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1?"end of input":"'" + (this.terminals_[symbol] || symbol) + "'"); 922 } 923 this.parseError(errStr, {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected}); 924 } 925 } 926 if (action[0] instanceof Array && action.length > 1) { 927 throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol); 928 } 929 switch (action[0]) { 930 case 1: 931 stack.push(symbol); 932 vstack.push(this.lexer.yytext); 933 lstack.push(this.lexer.yylloc); 934 stack.push(action[1]); 935 symbol = null; 936 if (!preErrorSymbol) { 937 yyleng = this.lexer.yyleng; 938 yytext = this.lexer.yytext; 939 yylineno = this.lexer.yylineno; 940 yyloc = this.lexer.yylloc; 941 if (recovering > 0) 942 recovering--; 943 } else { 944 symbol = preErrorSymbol; 945 preErrorSymbol = null; 946 } 947 break; 948 case 2: 949 len = this.productions_[action[1]][1]; 950 yyval.$ = vstack[vstack.length - len]; 951 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}; 952 if (ranges) { 953 yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]]; 954 } 955 r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack); 956 if (typeof r !== "undefined") { 957 return r; 958 } 959 if (len) { 960 stack = stack.slice(0, -1 * len * 2); 961 vstack = vstack.slice(0, -1 * len); 962 lstack = lstack.slice(0, -1 * len); 963 } 964 stack.push(this.productions_[action[1]][0]); 965 vstack.push(yyval.$); 966 lstack.push(yyval._$); 967 newState = table[stack[stack.length - 2]][stack[stack.length - 1]]; 968 stack.push(newState); 969 break; 970 case 3: 971 return true; 972 } 973 } 974 return true; 975 } 976 }; 977 978 979 function stripFlags(open, close) { 980 return { 981 left: open.charAt(2) === '~', 982 right: close.charAt(0) === '~' || close.charAt(1) === '~' 983 }; 984 } 985 986 /* Jison generated lexer */ 987 var lexer = (function(){ 988 var lexer = ({EOF:1, 989 parseError:function parseError(str, hash) { 990 if (this.yy.parser) { 991 this.yy.parser.parseError(str, hash); 992 } else { 993 throw new Error(str); 994 } 995 }, 996 setInput:function (input) { 997 this._input = input; 998 this._more = this._less = this.done = false; 999 this.yylineno = this.yyleng = 0; 1000 this.yytext = this.matched = this.match = ''; 1001 this.conditionStack = ['INITIAL']; 1002 this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0}; 1003 if (this.options.ranges) this.yylloc.range = [0,0]; 1004 this.offset = 0; 1005 return this; 1006 }, 1007 input:function () { 1008 var ch = this._input[0]; 1009 this.yytext += ch; 1010 this.yyleng++; 1011 this.offset++; 1012 this.match += ch; 1013 this.matched += ch; 1014 var lines = ch.match(/(?:\r\n?|\n).*/g); 1015 if (lines) { 1016 this.yylineno++; 1017 this.yylloc.last_line++; 1018 } else { 1019 this.yylloc.last_column++; 1020 } 1021 if (this.options.ranges) this.yylloc.range[1]++; 1022 1023 this._input = this._input.slice(1); 1024 return ch; 1025 }, 1026 unput:function (ch) { 1027 var len = ch.length; 1028 var lines = ch.split(/(?:\r\n?|\n)/g); 1029 1030 this._input = ch + this._input; 1031 this.yytext = this.yytext.substr(0, this.yytext.length-len-1); 1032 //this.yyleng -= len; 1033 this.offset -= len; 1034 var oldLines = this.match.split(/(?:\r\n?|\n)/g); 1035 this.match = this.match.substr(0, this.match.length-1); 1036 this.matched = this.matched.substr(0, this.matched.length-1); 1037 1038 if (lines.length-1) this.yylineno -= lines.length-1; 1039 var r = this.yylloc.range; 1040 1041 this.yylloc = {first_line: this.yylloc.first_line, 1042 last_line: this.yylineno+1, 1043 first_column: this.yylloc.first_column, 1044 last_column: lines ? 1045 (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length: 1046 this.yylloc.first_column - len 1047 }; 1048 1049 if (this.options.ranges) { 1050 this.yylloc.range = [r[0], r[0] + this.yyleng - len]; 1051 } 1052 return this; 1053 }, 1054 more:function () { 1055 this._more = true; 1056 return this; 1057 }, 1058 less:function (n) { 1059 this.unput(this.match.slice(n)); 1060 }, 1061 pastInput:function () { 1062 var past = this.matched.substr(0, this.matched.length - this.match.length); 1063 return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, ""); 1064 }, 1065 upcomingInput:function () { 1066 var next = this.match; 1067 if (next.length < 20) { 1068 next += this._input.substr(0, 20-next.length); 1069 } 1070 return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, ""); 1071 }, 1072 showPosition:function () { 1073 var pre = this.pastInput(); 1074 var c = new Array(pre.length + 1).join("-"); 1075 return pre + this.upcomingInput() + "\n" + c+"^"; 1076 }, 1077 next:function () { 1078 if (this.done) { 1079 return this.EOF; 1080 } 1081 if (!this._input) this.done = true; 1082 1083 var token, 1084 match, 1085 tempMatch, 1086 index, 1087 col, 1088 lines; 1089 if (!this._more) { 1090 this.yytext = ''; 1091 this.match = ''; 1092 } 1093 var rules = this._currentRules(); 1094 for (var i=0;i < rules.length; i++) { 1095 tempMatch = this._input.match(this.rules[rules[i]]); 1096 if (tempMatch && (!match || tempMatch[0].length > match[0].length)) { 1097 match = tempMatch; 1098 index = i; 1099 if (!this.options.flex) break; 1100 } 1101 } 1102 if (match) { 1103 lines = match[0].match(/(?:\r\n?|\n).*/g); 1104 if (lines) this.yylineno += lines.length; 1105 this.yylloc = {first_line: this.yylloc.last_line, 1106 last_line: this.yylineno+1, 1107 first_column: this.yylloc.last_column, 1108 last_column: lines ? lines[lines.length-1].length-lines[lines.length-1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length}; 1109 this.yytext += match[0]; 1110 this.match += match[0]; 1111 this.matches = match; 1112 this.yyleng = this.yytext.length; 1113 if (this.options.ranges) { 1114 this.yylloc.range = [this.offset, this.offset += this.yyleng]; 1115 } 1116 this._more = false; 1117 this._input = this._input.slice(match[0].length); 1118 this.matched += match[0]; 1119 token = this.performAction.call(this, this.yy, this, rules[index],this.conditionStack[this.conditionStack.length-1]); 1120 if (this.done && this._input) this.done = false; 1121 if (token) return token; 1122 else return; 1123 } 1124 if (this._input === "") { 1125 return this.EOF; 1126 } else { 1127 return this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(), 1128 {text: "", token: null, line: this.yylineno}); 1129 } 1130 }, 1131 lex:function lex() { 1132 var r = this.next(); 1133 if (typeof r !== 'undefined') { 1134 return r; 1135 } else { 1136 return this.lex(); 1137 } 1138 }, 1139 begin:function begin(condition) { 1140 this.conditionStack.push(condition); 1141 }, 1142 popState:function popState() { 1143 return this.conditionStack.pop(); 1144 }, 1145 _currentRules:function _currentRules() { 1146 return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules; 1147 }, 1148 topState:function () { 1149 return this.conditionStack[this.conditionStack.length-2]; 1150 }, 1151 pushState:function begin(condition) { 1152 this.begin(condition); 1153 }}); 1154 lexer.options = {}; 1155 lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) { 1156 1157 1158 function strip(start, end) { 1159 return yy_.yytext = yy_.yytext.substr(start, yy_.yyleng-end); 1160 } 1161 1162 1163 var YYSTATE=YY_START 1164 switch($avoiding_name_collisions) { 1165 case 0: 1166 if(yy_.yytext.slice(-2) === "\\\\") { 1167 strip(0,1); 1168 this.begin("mu"); 1169 } else if(yy_.yytext.slice(-1) === "\\") { 1170 strip(0,1); 1171 this.begin("emu"); 1172 } else { 1173 this.begin("mu"); 1174 } 1175 if(yy_.yytext) return 14; 1176 1177 break; 1178 case 1:return 14; 1179 break; 1180 case 2: 1181 this.popState(); 1182 return 14; 1183 1184 break; 1185 case 3:strip(0,4); this.popState(); return 15; 1186 break; 1187 case 4:return 35; 1188 break; 1189 case 5:return 36; 1190 break; 1191 case 6:return 25; 1192 break; 1193 case 7:return 16; 1194 break; 1195 case 8:return 20; 1196 break; 1197 case 9:return 19; 1198 break; 1199 case 10:return 19; 1200 break; 1201 case 11:return 23; 1202 break; 1203 case 12:return 22; 1204 break; 1205 case 13:this.popState(); this.begin('com'); 1206 break; 1207 case 14:strip(3,5); this.popState(); return 15; 1208 break; 1209 case 15:return 22; 1210 break; 1211 case 16:return 41; 1212 break; 1213 case 17:return 40; 1214 break; 1215 case 18:return 40; 1216 break; 1217 case 19:return 44; 1218 break; 1219 case 20:// ignore whitespace 1220 break; 1221 case 21:this.popState(); return 24; 1222 break; 1223 case 22:this.popState(); return 18; 1224 break; 1225 case 23:yy_.yytext = strip(1,2).replace(/\\"/g,'"'); return 32; 1226 break; 1227 case 24:yy_.yytext = strip(1,2).replace(/\\'/g,"'"); return 32; 1228 break; 1229 case 25:return 42; 1230 break; 1231 case 26:return 34; 1232 break; 1233 case 27:return 34; 1234 break; 1235 case 28:return 33; 1236 break; 1237 case 29:return 40; 1238 break; 1239 case 30:yy_.yytext = strip(1,2); return 40; 1240 break; 1241 case 31:return 'INVALID'; 1242 break; 1243 case 32:return 5; 1244 break; 1245 } 1246 }; 1247 lexer.rules = [/^(?:[^\x00]*?(?=(\{\{)))/,/^(?:[^\x00]+)/,/^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/,/^(?:[\s\S]*?--\}\})/,/^(?:\()/,/^(?:\))/,/^(?:\{\{(~)?>)/,/^(?:\{\{(~)?#)/,/^(?:\{\{(~)?\/)/,/^(?:\{\{(~)?\^)/,/^(?:\{\{(~)?\s*else\b)/,/^(?:\{\{(~)?\{)/,/^(?:\{\{(~)?&)/,/^(?:\{\{!--)/,/^(?:\{\{![\s\S]*?\}\})/,/^(?:\{\{(~)?)/,/^(?:=)/,/^(?:\.\.)/,/^(?:\.(?=([=~}\s\/.)])))/,/^(?:[\/.])/,/^(?:\s+)/,/^(?:\}(~)?\}\})/,/^(?:(~)?\}\})/,/^(?:"(\\["]|[^"])*")/,/^(?:'(\\[']|[^'])*')/,/^(?:@)/,/^(?:true(?=([~}\s)])))/,/^(?:false(?=([~}\s)])))/,/^(?:-?[0-9]+(?=([~}\s)])))/,/^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)]))))/,/^(?:\[[^\]]*\])/,/^(?:.)/,/^(?:$)/]; 1248 lexer.conditions = {"mu":{"rules":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32],"inclusive":false},"emu":{"rules":[2],"inclusive":false},"com":{"rules":[3],"inclusive":false},"INITIAL":{"rules":[0,1,32],"inclusive":true}}; 1249 return lexer;})() 1250 parser.lexer = lexer; 1251 function Parser () { this.yy = {}; }Parser.prototype = parser;parser.Parser = Parser; 1252 return new Parser; 1253 })();__exports__ = handlebars; 1254 /* jshint ignore:end */ 1255 return __exports__; 1256})(); 1257 1258// handlebars/compiler/base.js 1259var __module8__ = (function(__dependency1__, __dependency2__) { 1260 "use strict"; 1261 var __exports__ = {}; 1262 var parser = __dependency1__; 1263 var AST = __dependency2__; 1264 1265 __exports__.parser = parser; 1266 1267 function parse(input) { 1268 // Just return if an already-compile AST was passed in. 1269 if(input.constructor === AST.ProgramNode) { return input; } 1270 1271 parser.yy = AST; 1272 return parser.parse(input); 1273 } 1274 1275 __exports__.parse = parse; 1276 return __exports__; 1277})(__module9__, __module7__); 1278 1279// handlebars/compiler/compiler.js 1280var __module10__ = (function(__dependency1__) { 1281 "use strict"; 1282 var __exports__ = {}; 1283 var Exception = __dependency1__; 1284 1285 function Compiler() {} 1286 1287 __exports__.Compiler = Compiler;// the foundHelper register will disambiguate helper lookup from finding a 1288 // function in a context. This is necessary for mustache compatibility, which 1289 // requires that context functions in blocks are evaluated by blockHelperMissing, 1290 // and then proceed as if the resulting value was provided to blockHelperMissing. 1291 1292 Compiler.prototype = { 1293 compiler: Compiler, 1294 1295 disassemble: function() { 1296 var opcodes = this.opcodes, opcode, out = [], params, param; 1297 1298 for (var i=0, l=opcodes.length; i<l; i++) { 1299 opcode = opcodes[i]; 1300 1301 if (opcode.opcode === 'DECLARE') { 1302 out.push("DECLARE " + opcode.name + "=" + opcode.value); 1303 } else { 1304 params = []; 1305 for (var j=0; j<opcode.args.length; j++) { 1306 param = opcode.args[j]; 1307 if (typeof param === "string") { 1308 param = "\"" + param.replace("\n", "\\n") + "\""; 1309 } 1310 params.push(param); 1311 } 1312 out.push(opcode.opcode + " " + params.join(" ")); 1313 } 1314 } 1315 1316 return out.join("\n"); 1317 }, 1318 1319 equals: function(other) { 1320 var len = this.opcodes.length; 1321 if (other.opcodes.length !== len) { 1322 return false; 1323 } 1324 1325 for (var i = 0; i < len; i++) { 1326 var opcode = this.opcodes[i], 1327 otherOpcode = other.opcodes[i]; 1328 if (opcode.opcode !== otherOpcode.opcode || opcode.args.length !== otherOpcode.args.length) { 1329 return false; 1330 } 1331 for (var j = 0; j < opcode.args.length; j++) { 1332 if (opcode.args[j] !== otherOpcode.args[j]) { 1333 return false; 1334 } 1335 } 1336 } 1337 1338 len = this.children.length; 1339 if (other.children.length !== len) { 1340 return false; 1341 } 1342 for (i = 0; i < len; i++) { 1343 if (!this.children[i].equals(other.children[i])) { 1344 return false; 1345 } 1346 } 1347 1348 return true; 1349 }, 1350 1351 guid: 0, 1352 1353 compile: function(program, options) { 1354 this.opcodes = []; 1355 this.children = []; 1356 this.depths = {list: []}; 1357 this.options = options; 1358 1359 // These changes will propagate to the other compiler components 1360 var knownHelpers = this.options.knownHelpers; 1361 this.options.knownHelpers = { 1362 'helperMissing': true, 1363 'blockHelperMissing': true, 1364 'each': true, 1365 'if': true, 1366 'unless': true, 1367 'with': true, 1368 'log': true 1369 }; 1370 if (knownHelpers) { 1371 for (var name in knownHelpers) { 1372 this.options.knownHelpers[name] = knownHelpers[name]; 1373 } 1374 } 1375 1376 return this.accept(program); 1377 }, 1378 1379 accept: function(node) { 1380 var strip = node.strip || {}, 1381 ret; 1382 if (strip.left) { 1383 this.opcode('strip'); 1384 } 1385 1386 ret = this[node.type](node); 1387 1388 if (strip.right) { 1389 this.opcode('strip'); 1390 } 1391 1392 return ret; 1393 }, 1394 1395 program: function(program) { 1396 var statements = program.statements; 1397 1398 for(var i=0, l=statements.length; i<l; i++) { 1399 this.accept(statements[i]); 1400 } 1401 this.isSimple = l === 1; 1402 1403 this.depths.list = this.depths.list.sort(function(a, b) { 1404 return a - b; 1405 }); 1406 1407 return this; 1408 }, 1409 1410 compileProgram: function(program) { 1411 var result = new this.compiler().compile(program, this.options); 1412 var guid = this.guid++, depth; 1413 1414 this.usePartial = this.usePartial || result.usePartial; 1415 1416 this.children[guid] = result; 1417 1418 for(var i=0, l=result.depths.list.length; i<l; i++) { 1419 depth = result.depths.list[i]; 1420 1421 if(depth < 2) { continue; } 1422 else { this.addDepth(depth - 1); } 1423 } 1424 1425 return guid; 1426 }, 1427 1428 block: function(block) { 1429 var mustache = block.mustache, 1430 program = block.program, 1431 inverse = block.inverse; 1432 1433 if (program) { 1434 program = this.compileProgram(program); 1435 } 1436 1437 if (inverse) { 1438 inverse = this.compileProgram(inverse); 1439 } 1440 1441 var sexpr = mustache.sexpr; 1442 var type = this.classifySexpr(sexpr); 1443 1444 if (type === "helper") { 1445 this.helperSexpr(sexpr, program, inverse); 1446 } else if (type === "simple") { 1447 this.simpleSexpr(sexpr); 1448 1449 // now that the simple mustache is resolved, we need to 1450 // evaluate it by executing `blockHelperMissing` 1451 this.opcode('pushProgram', program); 1452 this.opcode('pushProgram', inverse); 1453 this.opcode('emptyHash'); 1454 this.opcode('blockValue'); 1455 } else { 1456 this.ambiguousSexpr(sexpr, program, inverse); 1457 1458 // now that the simple mustache is resolved, we need to 1459 // evaluate it by executing `blockHelperMissing` 1460 this.opcode('pushProgram', program); 1461 this.opcode('pushProgram', inverse); 1462 this.opcode('emptyHash'); 1463 this.opcode('ambiguousBlockValue'); 1464 } 1465 1466 this.opcode('append'); 1467 }, 1468 1469 hash: function(hash) { 1470 var pairs = hash.pairs, pair, val; 1471 1472 this.opcode('pushHash'); 1473 1474 for(var i=0, l=pairs.length; i<l; i++) { 1475 pair = pairs[i]; 1476 val = pair[1]; 1477 1478 if (this.options.stringParams) { 1479 if(val.depth) { 1480 this.addDepth(val.depth); 1481 } 1482 this.opcode('getContext', val.depth || 0); 1483 this.opcode('pushStringParam', val.stringModeValue, val.type); 1484 1485 if (val.type === 'sexpr') { 1486 // Subexpressions get evaluated and passed in 1487 // in string params mode. 1488 this.sexpr(val); 1489 } 1490 } else { 1491 this.accept(val); 1492 } 1493 1494 this.opcode('assignToHash', pair[0]); 1495 } 1496 this.opcode('popHash'); 1497 }, 1498 1499 partial: function(partial) { 1500 var partialName = partial.partialName; 1501 this.usePartial = true; 1502 1503 if(partial.context) { 1504 this.ID(partial.context); 1505 } else { 1506 this.opcode('push', 'depth0'); 1507 } 1508 1509 this.opcode('invokePartial', partialName.name); 1510 this.opcode('append'); 1511 }, 1512 1513 content: function(content) { 1514 this.opcode('appendContent', content.string); 1515 }, 1516 1517 mustache: function(mustache) { 1518 this.sexpr(mustache.sexpr); 1519 1520 if(mustache.escaped && !this.options.noEscape) { 1521 this.opcode('appendEscaped'); 1522 } else { 1523 this.opcode('append'); 1524 } 1525 }, 1526 1527 ambiguousSexpr: function(sexpr, program, inverse) { 1528 var id = sexpr.id, 1529 name = id.parts[0], 1530 isBlock = program != null || inverse != null; 1531 1532 this.opcode('getContext', id.depth); 1533 1534 this.opcode('pushProgram', program); 1535 this.opcode('pushProgram', inverse); 1536 1537 this.opcode('invokeAmbiguous', name, isBlock); 1538 }, 1539 1540 simpleSexpr: function(sexpr) { 1541 var id = sexpr.id; 1542 1543 if (id.type === 'DATA') { 1544 this.DATA(id); 1545 } else if (id.parts.length) { 1546 this.ID(id); 1547 } else { 1548 // Simplified ID for `this` 1549 this.addDepth(id.depth); 1550 this.opcode('getContext', id.depth); 1551 this.opcode('pushContext'); 1552 } 1553 1554 this.opcode('resolvePossibleLambda'); 1555 }, 1556 1557 helperSexpr: function(sexpr, program, inverse) { 1558 var params = this.setupFullMustacheParams(sexpr, program, inverse), 1559 name = sexpr.id.parts[0]; 1560 1561 if (this.options.knownHelpers[name]) { 1562 this.opcode('invokeKnownHelper', params.length, name); 1563 } else if (this.options.knownHelpersOnly) { 1564 throw new Exception("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr); 1565 } else { 1566 this.opcode('invokeHelper', params.length, name, sexpr.isRoot); 1567 } 1568 }, 1569 1570 sexpr: function(sexpr) { 1571 var type = this.classifySexpr(sexpr); 1572 1573 if (type === "simple") { 1574 this.simpleSexpr(sexpr); 1575 } else if (type === "helper") { 1576 this.helperSexpr(sexpr); 1577 } else { 1578 this.ambiguousSexpr(sexpr); 1579 } 1580 }, 1581 1582 ID: function(id) { 1583 this.addDepth(id.depth); 1584 this.opcode('getContext', id.depth); 1585 1586 var name = id.parts[0]; 1587 if (!name) { 1588 this.opcode('pushContext'); 1589 } else { 1590 this.opcode('lookupOnContext', id.parts[0]); 1591 } 1592 1593 for(var i=1, l=id.parts.length; i<l; i++) { 1594 this.opcode('lookup', id.parts[i]); 1595 } 1596 }, 1597 1598 DATA: function(data) { 1599 this.options.data = true; 1600 if (data.id.isScoped || data.id.depth) { 1601 throw new Exception('Scoped data references are not supported: ' + data.original, data); 1602 } 1603 1604 this.opcode('lookupData'); 1605 var parts = data.id.parts; 1606 for(var i=0, l=parts.length; i<l; i++) { 1607 this.opcode('lookup', parts[i]); 1608 } 1609 }, 1610 1611 STRING: function(string) { 1612 this.opcode('pushString', string.string); 1613 }, 1614 1615 INTEGER: function(integer) { 1616 this.opcode('pushLiteral', integer.integer); 1617 }, 1618 1619 BOOLEAN: function(bool) { 1620 this.opcode('pushLiteral', bool.bool); 1621 }, 1622 1623 comment: function() {}, 1624 1625 // HELPERS 1626 opcode: function(name) { 1627 this.opcodes.push({ opcode: name, args: [].slice.call(arguments, 1) }); 1628 }, 1629 1630 declare: function(name, value) { 1631 this.opcodes.push({ opcode: 'DECLARE', name: name, value: value }); 1632 }, 1633 1634 addDepth: function(depth) { 1635 if(depth === 0) { return; } 1636 1637 if(!this.depths[depth]) { 1638 this.depths[depth] = true; 1639 this.depths.list.push(depth); 1640 } 1641 }, 1642 1643 classifySexpr: function(sexpr) { 1644 var isHelper = sexpr.isHelper; 1645 var isEligible = sexpr.eligibleHelper; 1646 var options = this.options; 1647 1648 // if ambiguous, we can possibly resolve the ambiguity now 1649 if (isEligible && !isHelper) { 1650 var name = sexpr.id.parts[0]; 1651 1652 if (options.knownHelpers[name]) { 1653 isHelper = true; 1654 } else if (options.knownHelpersOnly) { 1655 isEligible = false; 1656 } 1657 } 1658 1659 if (isHelper) { return "helper"; } 1660 else if (isEligible) { return "ambiguous"; } 1661 else { return "simple"; } 1662 }, 1663 1664 pushParams: function(params) { 1665 var i = params.length, param; 1666 1667 while(i--) { 1668 param = params[i]; 1669 1670 if(this.options.stringParams) { 1671 if(param.depth) { 1672 this.addDepth(param.depth); 1673 } 1674 1675 this.opcode('getContext', param.depth || 0); 1676 this.opcode('pushStringParam', param.stringModeValue, param.type); 1677 1678 if (param.type === 'sexpr') { 1679 // Subexpressions get evaluated and passed in 1680 // in string params mode. 1681 this.sexpr(param); 1682 } 1683 } else { 1684 this[param.type](param); 1685 } 1686 } 1687 }, 1688 1689 setupFullMustacheParams: function(sexpr, program, inverse) { 1690 var params = sexpr.params; 1691 this.pushParams(params); 1692 1693 this.opcode('pushProgram', program); 1694 this.opcode('pushProgram', inverse); 1695 1696 if (sexpr.hash) { 1697 this.hash(sexpr.hash); 1698 } else { 1699 this.opcode('emptyHash'); 1700 } 1701 1702 return params; 1703 } 1704 }; 1705 1706 function precompile(input, options, env) { 1707 if (input == null || (typeof input !== 'string' && input.constructor !== env.AST.ProgramNode)) { 1708 throw new Exception("You must pass a string or Handlebars AST to Handlebars.precompile. You passed " + input); 1709 } 1710 1711 options = options || {}; 1712 if (!('data' in options)) { 1713 options.data = true; 1714 } 1715 1716 var ast = env.parse(input); 1717 var environment = new env.Compiler().compile(ast, options); 1718 return new env.JavaScriptCompiler().compile(environment, options); 1719 } 1720 1721 __exports__.precompile = precompile;function compile(input, options, env) { 1722 if (input == null || (typeof input !== 'string' && input.constructor !== env.AST.ProgramNode)) { 1723 throw new Exception("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input); 1724 } 1725 1726 options = options || {}; 1727 1728 if (!('data' in options)) { 1729 options.data = true; 1730 } 1731 1732 var compiled; 1733 1734 function compileInput() { 1735 var ast = env.parse(input); 1736 var environment = new env.Compiler().compile(ast, options); 1737 var templateSpec = new env.JavaScriptCompiler().compile(environment, options, undefined, true); 1738 return env.template(templateSpec); 1739 } 1740 1741 // Template is only compiled on first use and cached after that point. 1742 return function(context, options) { 1743 if (!compiled) { 1744 compiled = compileInput(); 1745 } 1746 return compiled.call(this, context, options); 1747 }; 1748 } 1749 1750 __exports__.compile = compile; 1751 return __exports__; 1752})(__module5__); 1753 1754// handlebars/compiler/javascript-compiler.js 1755var __module11__ = (function(__dependency1__, __dependency2__) { 1756 "use strict"; 1757 var __exports__; 1758 var COMPILER_REVISION = __dependency1__.COMPILER_REVISION; 1759 var REVISION_CHANGES = __dependency1__.REVISION_CHANGES; 1760 var log = __dependency1__.log; 1761 var Exception = __dependency2__; 1762 1763 function Literal(value) { 1764 this.value = value; 1765 } 1766 1767 function JavaScriptCompiler() {} 1768 1769 JavaScriptCompiler.prototype = { 1770 // PUBLIC API: You can override these methods in a subclass to provide 1771 // alternative compiled forms for name lookup and buffering semantics 1772 nameLookup: function(parent, name /* , type*/) { 1773 var wrap, 1774 ret; 1775 if (parent.indexOf('depth') === 0) { 1776 wrap = true; 1777 } 1778 1779 if (/^[0-9]+$/.test(name)) { 1780 ret = parent + "[" + name + "]"; 1781 } else if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) { 1782 ret = parent + "." + name; 1783 } 1784 else { 1785 ret = parent + "['" + name + "']"; 1786 } 1787 1788 if (wrap) { 1789 return '(' + parent + ' && ' + ret + ')'; 1790 } else { 1791 return ret; 1792 } 1793 }, 1794 1795 compilerInfo: function() { 1796 var revision = COMPILER_REVISION, 1797 versions = REVISION_CHANGES[revision]; 1798 return "this.compilerInfo = ["+revision+",'"+versions+"'];\n"; 1799 }, 1800 1801 appendToBuffer: function(string) { 1802 if (this.environment.isSimple) { 1803 return "return " + string + ";"; 1804 } else { 1805 return { 1806 appendToBuffer: true, 1807 content: string, 1808 toString: function() { return "buffer += " + string + ";"; } 1809 }; 1810 } 1811 }, 1812 1813 initializeBuffer: function() { 1814 return this.quotedString(""); 1815 }, 1816 1817 namespace: "Handlebars", 1818 // END PUBLIC API 1819 1820 compile: function(environment, options, context, asObject) { 1821 this.environment = environment; 1822 this.options = options || {}; 1823 1824 log('debug', this.environment.disassemble() + "\n\n"); 1825 1826 this.name = this.environment.name; 1827 this.isChild = !!context; 1828 this.context = context || { 1829 programs: [], 1830 environments: [], 1831 aliases: { } 1832 }; 1833 1834 this.preamble(); 1835 1836 this.stackSlot = 0; 1837 this.stackVars = []; 1838 this.registers = { list: [] }; 1839 this.hashes = []; 1840 this.compileStack = []; 1841 this.inlineStack = []; 1842 1843 this.compileChildren(environment, options); 1844 1845 var opcodes = environment.opcodes, opcode; 1846 1847 this.i = 0; 1848 1849 for(var l=opcodes.length; this.i<l; this.i++) { 1850 opcode = opcodes[this.i]; 1851 1852 if(opcode.opcode === 'DECLARE') { 1853 this[opcode.name] = opcode.value; 1854 } else { 1855 this[opcode.opcode].apply(this, opcode.args); 1856 } 1857 1858 // Reset the stripNext flag if it was not set by this operation. 1859 if (opcode.opcode !== this.stripNext) { 1860 this.stripNext = false; 1861 } 1862 } 1863 1864 // Flush any trailing content that might be pending. 1865 this.pushSource(''); 1866 1867 if (this.stackSlot || this.inlineStack.length || this.compileStack.length) { 1868 throw new Exception('Compile completed with content left on stack'); 1869 } 1870 1871 return this.createFunctionContext(asObject); 1872 }, 1873 1874 preamble: function() { 1875 var out = []; 1876 1877 if (!this.isChild) { 1878 var namespace = this.namespace; 1879 1880 var copies = "helpers = this.merge(helpers, " + namespace + ".helpers);"; 1881 if (this.environment.usePartial) { copies = copies + " partials = this.merge(partials, " + namespace + ".partials);"; } 1882 if (this.options.data) { copies = copies + " data = data || {};"; } 1883 out.push(copies); 1884 } else { 1885 out.push(''); 1886 } 1887 1888 if (!this.environment.isSimple) { 1889 out.push(", buffer = " + this.initializeBuffer()); 1890 } else { 1891 out.push(""); 1892 } 1893 1894 // track the last context pushed into place to allow skipping the 1895 // getContext opcode when it would be a noop 1896 this.lastContext = 0; 1897 this.source = out; 1898 }, 1899 1900 createFunctionContext: function(asObject) { 1901 var locals = this.stackVars.concat(this.registers.list); 1902 1903 if(locals.length > 0) { 1904 this.source[1] = this.source[1] + ", " + locals.join(", "); 1905 } 1906 1907 // Generate minimizer alias mappings 1908 if (!this.isChild) { 1909 for (var alias in this.context.aliases) { 1910 if (this.context.aliases.hasOwnProperty(alias)) { 1911 this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias]; 1912 } 1913 } 1914 } 1915 1916 if (this.source[1]) { 1917 this.source[1] = "var " + this.source[1].substring(2) + ";"; 1918 } 1919 1920 // Merge children 1921 if (!this.isChild) { 1922 this.source[1] += '\n' + this.context.programs.join('\n') + '\n'; 1923 } 1924 1925 if (!this.environment.isSimple) { 1926 this.pushSource("return buffer;"); 1927 } 1928 1929 var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"]; 1930 1931 for(var i=0, l=this.environment.depths.list.length; i<l; i++) { 1932 params.push("depth" + this.environment.depths.list[i]); 1933 } 1934 1935 // Perform a second pass over the output to merge content when possible 1936 var source = this.mergeSource(); 1937 1938 if (!this.isChild) { 1939 source = this.compilerInfo()+source; 1940 } 1941 1942 if (asObject) { 1943 params.push(source); 1944 1945 return Function.apply(this, params); 1946 } else { 1947 var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n ' + source + '}'; 1948 log('debug', functionSource + "\n\n"); 1949 return functionSource; 1950 } 1951 }, 1952 mergeSource: function() { 1953 // WARN: We are not handling the case where buffer is still populated as the source should 1954 // not have buffer append operations as their final action. 1955 var source = '', 1956 buffer; 1957 for (var i = 0, len = this.source.length; i < len; i++) { 1958 var line = this.source[i]; 1959 if (line.appendToBuffer) { 1960 if (buffer) { 1961 buffer = buffer + '\n + ' + line.content; 1962 } else { 1963 buffer = line.content; 1964 } 1965 } else { 1966 if (buffer) { 1967 source += 'buffer += ' + buffer + ';\n '; 1968 buffer = undefined; 1969 } 1970 source += line + '\n '; 1971 } 1972 } 1973 return source; 1974 }, 1975 1976 // [blockValue] 1977 // 1978 // On stack, before: hash, inverse, program, value 1979 // On stack, after: return value of blockHelperMissing 1980 // 1981 // The purpose of this opcode is to take a block of the form 1982 // `{{#foo}}...{{/foo}}`, resolve the value of `foo`, and 1983 // replace it on the stack with the result of properly 1984 // invoking blockHelperMissing. 1985 blockValue: function() { 1986 this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing'; 1987 1988 var params = ["depth0"]; 1989 this.setupParams(0, params); 1990 1991 this.replaceStack(function(current) { 1992 params.splice(1, 0, current); 1993 return "blockHelperMissing.call(" + params.join(", ") + ")"; 1994 }); 1995 }, 1996 1997 // [ambiguousBlockValue] 1998 // 1999 // On stack, before: hash, inverse, program, value 2000 // Compiler value, before: lastHelper=value of last found helper, if any 2001 // On stack, after, if no lastHelper: same as [blockValue] 2002 // On stack, after, if lastHelper: value 2003 ambiguousBlockValue: function() { 2004 this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing'; 2005 2006 var params = ["depth0"]; 2007 this.setupParams(0, params); 2008 2009 var current = this.topStack(); 2010 params.splice(1, 0, current); 2011 2012 this.pushSource("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }"); 2013 }, 2014 2015 // [appendContent] 2016 // 2017 // On stack, before: ... 2018 // On stack, after: ... 2019 // 2020 // Appends the string value of `content` to the current buffer 2021 appendContent: function(content) { 2022 if (this.pendingContent) { 2023 content = this.pendingContent + content; 2024 } 2025 if (this.stripNext) { 2026 content = content.replace(/^\s+/, ''); 2027 } 2028 2029 this.pendingContent = content; 2030 }, 2031 2032 // [strip] 2033 // 2034 // On stack, before: ... 2035 // On stack, after: ... 2036 // 2037 // Removes any trailing whitespace from the prior content node and flags 2038 // the next operation for stripping if it is a content node. 2039 strip: function() { 2040 if (this.pendingContent) { 2041 this.pendingContent = this.pendingContent.replace(/\s+$/, ''); 2042 } 2043 this.stripNext = 'strip'; 2044 }, 2045 2046 // [append] 2047 // 2048 // On stack, before: value, ... 2049 // On stack, after: ... 2050 // 2051 // Coerces `value` to a String and appends it to the current buffer. 2052 // 2053 // If `value` is truthy, or 0, it is coerced into a string and appended 2054 // Otherwise, the empty string is appended 2055 append: function() { 2056 // Force anything that is inlined onto the stack so we don't have duplication 2057 // when we examine local 2058 this.flushInline(); 2059 var local = this.popStack(); 2060 this.pushSource("if(" + local + " || " + local + " === 0) { " + this.appendToBuffer(local) + " }"); 2061 if (this.environment.isSimple) { 2062 this.pushSource("else { " + this.appendToBuffer("''") + " }"); 2063 } 2064 }, 2065 2066 // [appendEscaped] 2067 // 2068 // On stack, before: value, ... 2069 // On stack, after: ... 2070 // 2071 // Escape `value` and append it to the buffer 2072 appendEscaped: function() { 2073 this.context.aliases.escapeExpression = 'this.escapeExpression'; 2074 2075 this.pushSource(this.appendToBuffer("escapeExpression(" + this.popStack() + ")")); 2076 }, 2077 2078 // [getContext] 2079 // 2080 // On stack, before: ... 2081 // On stack, after: ... 2082 // Compiler value, after: lastContext=depth 2083 // 2084 // Set the value of the `lastContext` compiler value to the depth 2085 getContext: function(depth) { 2086 if(this.lastContext !== depth) { 2087 this.lastContext = depth; 2088 } 2089 }, 2090 2091 // [lookupOnContext] 2092 // 2093 // On stack, before: ... 2094 // On stack, after: currentContext[name], ... 2095 // 2096 // Looks up the value of `name` on the current context and pushes 2097 // it onto the stack. 2098 lookupOnContext: function(name) { 2099 this.push(this.nameLookup('depth' + this.lastContext, name, 'context')); 2100 }, 2101 2102 // [pushContext] 2103 // 2104 // On stack, before: ... 2105 // On stack, after: currentContext, ... 2106 // 2107 // Pushes the value of the current context onto the stack. 2108 pushContext: function() { 2109 this.pushStackLiteral('depth' + this.lastContext); 2110 }, 2111 2112 // [resolvePossibleLambda] 2113 // 2114 // On stack, before: value, ... 2115 // On stack, after: resolved value, ... 2116 // 2117 // If the `value` is a lambda, replace it on the stack by 2118 // the return value of the lambda 2119 resolvePossibleLambda: function() { 2120 this.context.aliases.functionType = '"function"'; 2121 2122 this.replaceStack(function(current) { 2123 return "typeof " + current + " === functionType ? " + current + ".apply(depth0) : " + current; 2124 }); 2125 }, 2126 2127 // [lookup] 2128 // 2129 // On stack, before: value, ... 2130 // On stack, after: value[name], ... 2131 // 2132 // Replace the value on the stack with the result of looking 2133 // up `name` on `value` 2134 lookup: function(name) { 2135 this.replaceStack(function(current) { 2136 return current + " == null || " + current + " === false ? " + current + " : " + this.nameLookup(current, name, 'context'); 2137 }); 2138 }, 2139 2140 // [lookupData] 2141 // 2142 // On stack, before: ... 2143 // On stack, after: data, ... 2144 // 2145 // Push the data lookup operator 2146 lookupData: function() { 2147 this.pushStackLiteral('data'); 2148 }, 2149 2150 // [pushStringParam] 2151 // 2152 // On stack, before: ... 2153 // On stack, after: string, currentContext, ... 2154 // 2155 // This opcode is designed for use in string mode, which 2156 // provides the string value of a parameter along with its 2157 // depth rather than resolving it immediately. 2158 pushStringParam: function(string, type) { 2159 this.pushStackLiteral('depth' + this.lastContext); 2160 2161 this.pushString(type); 2162 2163 // If it's a subexpression, the string result 2164 // will be pushed after this opcode. 2165 if (type !== 'sexpr') { 2166 if (typeof string === 'string') { 2167 this.pushString(string); 2168 } else { 2169 this.pushStackLiteral(string); 2170 } 2171 } 2172 }, 2173 2174 emptyHash: function() { 2175 this.pushStackLiteral('{}'); 2176 2177 if (this.options.stringParams) { 2178 this.push('{}'); // hashContexts 2179 this.push('{}'); // hashTypes 2180 } 2181 }, 2182 pushHash: function() { 2183 if (this.hash) { 2184 this.hashes.push(this.hash); 2185 } 2186 this.hash = {values: [], types: [], contexts: []}; 2187 }, 2188 popHash: function() { 2189 var hash = this.hash; 2190 this.hash = this.hashes.pop(); 2191 2192 if (this.options.stringParams) { 2193 this.push('{' + hash.contexts.join(',') + '}'); 2194 this.push('{' + hash.types.join(',') + '}'); 2195 } 2196 2197 this.push('{\n ' + hash.values.join(',\n ') + '\n }'); 2198 }, 2199 2200 // [pushString] 2201 // 2202 // On stack, before: ... 2203 // On stack, after: quotedString(string), ... 2204 // 2205 // Push a quoted version of `string` onto the stack 2206 pushString: function(string) { 2207 this.pushStackLiteral(this.quotedString(string)); 2208 }, 2209 2210 // [push] 2211 // 2212 // On stack, before: ... 2213 // On stack, after: expr, ... 2214 // 2215 // Push an expression onto the stack 2216 push: function(expr) { 2217 this.inlineStack.push(expr); 2218 return expr; 2219 }, 2220 2221 // [pushLiteral] 2222 // 2223 // On stack, before: ... 2224 // On stack, after: value, ... 2225 // 2226 // Pushes a value onto the stack. This operation prevents 2227 // the compiler from creating a temporary variable to hold 2228 // it. 2229 pushLiteral: function(value) { 2230 this.pushStackLiteral(value); 2231 }, 2232 2233 // [pushProgram] 2234 // 2235 // On stack, before: ... 2236 // On stack, after: program(guid), ... 2237 // 2238 // Push a program expression onto the stack. This takes 2239 // a compile-time guid and converts it into a runtime-accessible 2240 // expression. 2241 pushProgram: function(guid) { 2242 if (guid != null) { 2243 this.pushStackLiteral(this.programExpression(guid)); 2244 } else { 2245 this.pushStackLiteral(null); 2246 } 2247 }, 2248 2249 // [invokeHelper] 2250 // 2251 // On stack, before: hash, inverse, program, params..., ... 2252 // On stack, after: result of helper invocation 2253 // 2254 // Pops off the helper's parameters, invokes the helper, 2255 // and pushes the helper's return value onto the stack. 2256 // 2257 // If the helper is not found, `helperMissing` is called. 2258 invokeHelper: function(paramSize, name, isRoot) { 2259 this.context.aliases.helperMissing = 'helpers.helperMissing'; 2260 this.useRegister('helper'); 2261 2262 var helper = this.lastHelper = this.setupHelper(paramSize, name, true); 2263 var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context'); 2264 2265 var lookup = 'helper = ' + helper.name + ' || ' + nonHelper; 2266 if (helper.paramsInit) { 2267 lookup += ',' + helper.paramsInit; 2268 } 2269 2270 this.push( 2271 '(' 2272 + lookup 2273 + ',helper ' 2274 + '? helper.call(' + helper.callParams + ') ' 2275 + ': helperMissing.call(' + helper.helperMissingParams + '))'); 2276 2277 // Always flush subexpressions. This is both to prevent the compounding size issue that 2278 // occurs when the code has to be duplicated for inlining and also to prevent errors 2279 // due to the incorrect options object being passed due to the shared register. 2280 if (!isRoot) { 2281 this.flushInline(); 2282 } 2283 }, 2284 2285 // [invokeKnownHelper] 2286 // 2287 // On stack, before: hash, inverse, program, params..., ... 2288 // On stack, after: result of helper invocation 2289 // 2290 // This operation is used when the helper is known to exist, 2291 // so a `helperMissing` fallback is not required. 2292 invokeKnownHelper: function(paramSize, name) { 2293 var helper = this.setupHelper(paramSize, name); 2294 this.push(helper.name + ".call(" + helper.callParams + ")"); 2295 }, 2296 2297 // [invokeAmbiguous] 2298 // 2299 // On stack, before: hash, inverse, program, params..., ... 2300 // On stack, after: result of disambiguation 2301 // 2302 // This operation is used when an expression like `{{foo}}` 2303 // is provided, but we don't know at compile-time whether it 2304 // is a helper or a path. 2305 // 2306 // This operation emits more code than the other options, 2307 // and can be avoided by passing the `knownHelpers` and 2308 // `knownHelpersOnly` flags at compile-time. 2309 invokeAmbiguous: function(name, helperCall) { 2310 this.context.aliases.functionType = '"function"'; 2311 this.useRegister('helper'); 2312 2313 this.emptyHash(); 2314 var helper = this.setupHelper(0, name, helperCall); 2315 2316 var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper'); 2317 2318 var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context'); 2319 var nextStack = this.nextStack(); 2320 2321 if (helper.paramsInit) { 2322 this.pushSource(helper.paramsInit); 2323 } 2324 this.pushSource('if (helper = ' + helperName + ') { ' + nextStack + ' = helper.call(' + helper.callParams + '); }'); 2325 this.pushSource('else { helper = ' + nonHelper + '; ' + nextStack + ' = typeof helper === functionType ? helper.call(' + helper.callParams + ') : helper; }'); 2326 }, 2327 2328 // [invokePartial] 2329 // 2330 // On stack, before: context, ... 2331 // On stack after: result of partial invocation 2332 // 2333 // This operation pops off a context, invokes a partial with that context, 2334 // and pushes the result of the invocation back. 2335 invokePartial: function(name) { 2336 var params = [this.nameLookup('partials', name, 'partial'), "'" + name + "'", this.popStack(), "helpers", "partials"]; 2337 2338 if (this.options.data) { 2339 params.push("data"); 2340 } 2341 2342 this.context.aliases.self = "this"; 2343 this.push("self.invokePartial(" + params.join(", ") + ")"); 2344 }, 2345 2346 // [assignToHash] 2347 // 2348 // On stack, before: value, hash, ... 2349 // On stack, after: hash, ... 2350 // 2351 // Pops a value and hash off the stack, assigns `hash[key] = value` 2352 // and pushes the hash back onto the stack. 2353 assignToHash: function(key) { 2354 var value = this.popStack(), 2355 context, 2356 type; 2357 2358 if (this.options.stringParams) { 2359 type = this.popStack(); 2360 context = this.popStack(); 2361 } 2362 2363 var hash = this.hash; 2364 if (context) { 2365 hash.contexts.push("'" + key + "': " + context); 2366 } 2367 if (type) { 2368 hash.types.push("'" + key + "': " + type); 2369 } 2370 hash.values.push("'" + key + "': (" + value + ")"); 2371 }, 2372 2373 // HELPERS 2374 2375 compiler: JavaScriptCompiler, 2376 2377 compileChildren: function(environment, options) { 2378 var children = environment.children, child, compiler; 2379 2380 for(var i=0, l=children.length; i<l; i++) { 2381 child = children[i]; 2382 compiler = new this.compiler(); 2383 2384 var index = this.matchExistingProgram(child); 2385 2386 if (index == null) { 2387 this.context.programs.push(''); // Placeholder to prevent name conflicts for nested children 2388 index = this.context.programs.length; 2389 child.index = index; 2390 child.name = 'program' + index; 2391 this.context.programs[index] = compiler.compile(child, options, this.context); 2392 this.context.environments[index] = child; 2393 } else { 2394 child.index = index; 2395 child.name = 'program' + index; 2396 } 2397 } 2398 }, 2399 matchExistingProgram: function(child) { 2400 for (var i = 0, len = this.context.environments.length; i < len; i++) { 2401 var environment = this.context.environments[i]; 2402 if (environment && environment.equals(child)) { 2403 return i; 2404 } 2405 } 2406 }, 2407 2408 programExpression: function(guid) { 2409 this.context.aliases.self = "this"; 2410 2411 if(guid == null) { 2412 return "self.noop"; 2413 } 2414 2415 var child = this.environment.children[guid], 2416 depths = child.depths.list, depth; 2417 2418 var programParams = [child.index, child.name, "data"]; 2419 2420 for(var i=0, l = depths.length; i<l; i++) { 2421 depth = depths[i]; 2422 2423 if(depth === 1) { programParams.push("depth0"); } 2424 else { programParams.push("depth" + (depth - 1)); } 2425 } 2426 2427 return (depths.length === 0 ? "self.program(" : "self.programWithDepth(") + programParams.join(", ") + ")"; 2428 }, 2429 2430 register: function(name, val) { 2431 this.useRegister(name); 2432 this.pushSource(name + " = " + val + ";"); 2433 }, 2434 2435 useRegister: function(name) { 2436 if(!this.registers[name]) { 2437 this.registers[name] = true; 2438 this.registers.list.push(name); 2439 } 2440 }, 2441 2442 pushStackLiteral: function(item) { 2443 return this.push(new Literal(item)); 2444 }, 2445 2446 pushSource: function(source) { 2447 if (this.pendingContent) { 2448 this.source.push(this.appendToBuffer(this.quotedString(this.pendingContent))); 2449 this.pendingContent = undefined; 2450 } 2451 2452 if (source) { 2453 this.source.push(source); 2454 } 2455 }, 2456 2457 pushStack: function(item) { 2458 this.flushInline(); 2459 2460 var stack = this.incrStack(); 2461 if (item) { 2462 this.pushSource(stack + " = " + item + ";"); 2463 } 2464 this.compileStack.push(stack); 2465 return stack; 2466 }, 2467 2468 replaceStack: function(callback) { 2469 var prefix = '', 2470 inline = this.isInline(), 2471 stack, 2472 createdStack, 2473 usedLiteral; 2474 2475 // If we are currently inline then we want to merge the inline statement into the 2476 // replacement statement via ',' 2477 if (inline) { 2478 var top = this.popStack(true); 2479 2480 if (top instanceof Literal) { 2481 // Literals do not need to be inlined 2482 stack = top.value; 2483 usedLiteral = true; 2484 } else { 2485 // Get or create the current stack name for use by the inline 2486 createdStack = !this.stackSlot; 2487 var name = !createdStack ? this.topStackName() : this.incrStack(); 2488 2489 prefix = '(' + this.push(name) + ' = ' + top + '),'; 2490 stack = this.topStack(); 2491 } 2492 } else { 2493 stack = this.topStack(); 2494 } 2495 2496 var item = callback.call(this, stack); 2497 2498 if (inline) { 2499 if (!usedLiteral) { 2500 this.popStack(); 2501 } 2502 if (createdStack) { 2503 this.stackSlot--; 2504 } 2505 this.push('(' + prefix + item + ')'); 2506 } else { 2507 // Prevent modification of the context depth variable. Through replaceStack 2508 if (!/^stack/.test(stack)) { 2509 stack = this.nextStack(); 2510 } 2511 2512 this.pushSource(stack + " = (" + prefix + item + ");"); 2513 } 2514 return stack; 2515 }, 2516 2517 nextStack: function() { 2518 return this.pushStack(); 2519 }, 2520 2521 incrStack: function() { 2522 this.stackSlot++; 2523 if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); } 2524 return this.topStackName(); 2525 }, 2526 topStackName: function() { 2527 return "stack" + this.stackSlot; 2528 }, 2529 flushInline: function() { 2530 var inlineStack = this.inlineStack; 2531 if (inlineStack.length) { 2532 this.inlineStack = []; 2533 for (var i = 0, len = inlineStack.length; i < len; i++) { 2534 var entry = inlineStack[i]; 2535 if (entry instanceof Literal) { 2536 this.compileStack.push(entry); 2537 } else { 2538 this.pushStack(entry); 2539 } 2540 } 2541 } 2542 }, 2543 isInline: function() { 2544 return this.inlineStack.length; 2545 }, 2546 2547 popStack: function(wrapped) { 2548 var inline = this.isInline(), 2549 item = (inline ? this.inlineStack : this.compileStack).pop(); 2550 2551 if (!wrapped && (item instanceof Literal)) { 2552 return item.value; 2553 } else { 2554 if (!inline) { 2555 if (!this.stackSlot) { 2556 throw new Exception('Invalid stack pop'); 2557 } 2558 this.stackSlot--; 2559 } 2560 return item; 2561 } 2562 }, 2563 2564 topStack: function(wrapped) { 2565 var stack = (this.isInline() ? this.inlineStack : this.compileStack), 2566 item = stack[stack.length - 1]; 2567 2568 if (!wrapped && (item instanceof Literal)) { 2569 return item.value; 2570 } else { 2571 return item; 2572 } 2573 }, 2574 2575 quotedString: function(str) { 2576 return '"' + str 2577 .replace(/\\/g, '\\\\') 2578 .replace(/"/g, '\\"') 2579 .replace(/\n/g, '\\n') 2580 .replace(/\r/g, '\\r') 2581 .replace(/\u2028/g, '\\u2028') // Per Ecma-262 7.3 + 7.8.4 2582 .replace(/\u2029/g, '\\u2029') + '"'; 2583 }, 2584 2585 setupHelper: function(paramSize, name, missingParams) { 2586 var params = [], 2587 paramsInit = this.setupParams(paramSize, params, missingParams); 2588 var foundHelper = this.nameLookup('helpers', name, 'helper'); 2589 2590 return { 2591 params: params, 2592 paramsInit: paramsInit, 2593 name: foundHelper, 2594 callParams: ["depth0"].concat(params).join(", "), 2595 helperMissingParams: missingParams && ["depth0", this.quotedString(name)].concat(params).join(", ") 2596 }; 2597 }, 2598 2599 setupOptions: function(paramSize, params) { 2600 var options = [], contexts = [], types = [], param, inverse, program; 2601 2602 options.push("hash:" + this.popStack()); 2603 2604 if (this.options.stringParams) { 2605 options.push("hashTypes:" + this.popStack()); 2606 options.push("hashContexts:" + this.popStack()); 2607 } 2608 2609 inverse = this.popStack(); 2610 program = this.popStack(); 2611 2612 // Avoid setting fn and inverse if neither are set. This allows 2613 // helpers to do a check for `if (options.fn)` 2614 if (program || inverse) { 2615 if (!program) { 2616 this.context.aliases.self = "this"; 2617 program = "self.noop"; 2618 } 2619 2620 if (!inverse) { 2621 this.context.aliases.self = "this"; 2622 inverse = "self.noop"; 2623 } 2624 2625 options.push("inverse:" + inverse); 2626 options.push("fn:" + program); 2627 } 2628 2629 for(var i=0; i<paramSize; i++) { 2630 param = this.popStack(); 2631 params.push(param); 2632 2633 if(this.options.stringParams) { 2634 types.push(this.popStack()); 2635 contexts.push(this.popStack()); 2636 } 2637 } 2638 2639 if (this.options.stringParams) { 2640 options.push("contexts:[" + contexts.join(",") + "]"); 2641 options.push("types:[" + types.join(",") + "]"); 2642 } 2643 2644 if(this.options.data) { 2645 options.push("data:data"); 2646 } 2647 2648 return options; 2649 }, 2650 2651 // the params and contexts arguments are passed in arrays 2652 // to fill in 2653 setupParams: function(paramSize, params, useRegister) { 2654 var options = '{' + this.setupOptions(paramSize, params).join(',') + '}'; 2655 2656 if (useRegister) { 2657 this.useRegister('options'); 2658 params.push('options'); 2659 return 'options=' + options; 2660 } else { 2661 params.push(options); 2662 return ''; 2663 } 2664 } 2665 }; 2666 2667 var reservedWords = ( 2668 "break else new var" + 2669 " case finally return void" + 2670 " catch for switch while" + 2671 " continue function this with" + 2672 " default if throw" + 2673 " delete in try" + 2674 " do instanceof typeof" + 2675 " abstract enum int short" + 2676 " boolean export interface static" + 2677 " byte extends long super" + 2678 " char final native synchronized" + 2679 " class float package throws" + 2680 " const goto private transient" + 2681 " debugger implements protected volatile" + 2682 " double import public let yield" 2683 ).split(" "); 2684 2685 var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {}; 2686 2687 for(var i=0, l=reservedWords.length; i<l; i++) { 2688 compilerWords[reservedWords[i]] = true; 2689 } 2690 2691 JavaScriptCompiler.isValidJavaScriptVariableName = function(name) { 2692 if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name)) { 2693 return true; 2694 } 2695 return false; 2696 }; 2697 2698 __exports__ = JavaScriptCompiler; 2699 return __exports__; 2700})(__module2__, __module5__); 2701 2702// handlebars.js 2703var __module0__ = (function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) { 2704 "use strict"; 2705 var __exports__; 2706 /*globals Handlebars: true */ 2707 var Handlebars = __dependency1__; 2708 2709 // Compiler imports 2710 var AST = __dependency2__; 2711 var Parser = __dependency3__.parser; 2712 var parse = __dependency3__.parse; 2713 var Compiler = __dependency4__.Compiler; 2714 var compile = __dependency4__.compile; 2715 var precompile = __dependency4__.precompile; 2716 var JavaScriptCompiler = __dependency5__; 2717 2718 var _create = Handlebars.create; 2719 var create = function() { 2720 var hb = _create(); 2721 2722 hb.compile = function(input, options) { 2723 return compile(input, options, hb); 2724 }; 2725 hb.precompile = function (input, options) { 2726 return precompile(input, options, hb); 2727 }; 2728 2729 hb.AST = AST; 2730 hb.Compiler = Compiler; 2731 hb.JavaScriptCompiler = JavaScriptCompiler; 2732 hb.Parser = Parser; 2733 hb.parse = parse; 2734 2735 return hb; 2736 }; 2737 2738 Handlebars = create(); 2739 Handlebars.create = create; 2740 2741 __exports__ = Handlebars; 2742 return __exports__; 2743})(__module1__, __module7__, __module8__, __module10__, __module11__); 2744 2745 return __module0__; 2746})();
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.